{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
    "    !pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "    !pip install JSAnimation==0.1\n",
    "    !pip install pyglet==1.3.2\n",
    "    \n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 07. Behavior Cloning (without HER)\n",
    "\n",
    "[A. Nair et al., \"Overcoming Exploration in Reinforcement Learning with Demonstrations.\" arXiv preprint arXiv:1709.10089, 2017.](https://arxiv.org/pdf/1709.10089.pdf)\n",
    "\n",
    "Exploration in environments with sparse rewards has been a persistent problem in reinforcement learning. Many tasks are natural to  specify with a sparse reward, and manually shaping a reward function can result in suboptimal performance. However, finding a non-zero reward is exponentially more difficult with increasing task horizon or action dimensionality. In  this  paper, the authors use demonstrations to overcome the exploration problem and successfully learn to perform long-horizon, multi-step tasks with continuous control such as stacking blocks with a robot arm.\n",
    "\n",
    "### DDPG\n",
    "For learning in high-dimentional and continous action spaces, the authors of DDPG combine the actor-critic approach with insights from the recent success of DQN. Deep DPG(DDPG) is based on the deterministic policy gradient(DPG) algorithm ([Silver et al., 2014](http://proceedings.mlr.press/v32/silver14.pdf)). Please see *03.DDPG.ipynb* for detailed description of DDPG.\n",
    "\n",
    "### Demonstration Buffer\n",
    "It maintains a second replay buffer $R_D$ where we store our the demonstration data in the same format as the original replay buffer $R$. In each minibatch, we draw extra $N_D$ examples from $R_D$ to use as off-policy replay data for the update step. These examples are included in both the actor and critic update.\n",
    "\n",
    "### Behavior Cloning Loss\n",
    "It computes only on the demonstration examples for training the actor.\n",
    "$$\n",
    "L_{BC} = \\underset{i=1}{\\overset{N_D}\\sum} \\lVert \\pi (s_i | \\theta_\\pi) - a_i \\rVert^2\n",
    "$$\n",
    "This loss is a standard loss in imitation learning, but this paper shows that using it as an auxiliary loss for RL improves learning significantly. The gradient applied to the actor parameters $\\theta_\\pi$ is:\n",
    "$$\n",
    "L_A = - \\lambda_1 \\nabla_{\\theta_{\\pi}}J + \\lambda_2 \\nabla_{\\theta_{\\pi}} L_{BC}\n",
    "$$\n",
    "Two parameters called  $\\lambda_1$ ,  $\\lambda_2$  are used to weight the contributions.\n",
    "\n",
    "### Q-Filter\n",
    "Using the above loss prevents the learned policy from improving significantly beyond the demonstration policy, as the actor is always tied back to the demonstrations. To avoid this problem, the authors apply the behavior cloning loss only to states where the critic $Q(s,a)$ determines that action of the demonstration is better than actor's action:\n",
    "$$\n",
    "L_{BC} = \\underset{i=1}{\\overset{N_D}\\sum}\\lVert \\pi (s_i | \\theta_\\pi) - a_i \\rVert^2 \\mathbb{1}_{Q(s_i, a_i) > Q(s_i, \\pi(s_i))}\n",
    "$$\n",
    "\n",
    "### Hindsight Experience Replay (HER)\n",
    "The key insight of HER is that even in failed rollouts where no reward was obtained, the agent can transform them into successful ones by assuming that a state it saw in the rollout was the actual goal. It can be used with any off-policy RL algorithm assuming that for every state we can find a goal corresponding to this state.\n",
    "However, it needs parametrized goals setting, which can be sampled the goal $g$ at the beginning of every episode, so **we don't implement it**. Please see [this paper](https://arxiv.org/pdf/1707.01495) for detailed contents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import copy\n",
    "import random\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "from IPython.display import clear_output\n",
    "\n",
    "if IN_COLAB and not os.path.exists(\"demo.pkl\"):\n",
    "    # download demo.pkl\n",
    "    !wget https://raw.githubusercontent.com/mrsyee/pg-is-all-you-need/master/demo.pkl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "- collections.deque\n",
    "- list\n",
    "- numpy.ndarray\n",
    "\n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "In addition, we add `extend` method to store multi transitions like demonstration.\n",
    "\n",
    "Reference: \n",
    "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
    "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        \"\"\"Store the transition in buffer.\"\"\"\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "        \n",
    "    def extend(\n",
    "        self, \n",
    "        transitions: List[Tuple],\n",
    "    ):\n",
    "        \"\"\"Store the multi transitions in buffer.\"\"\"\n",
    "        for transition in transitions:\n",
    "            self.store(*transition)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OU Noise\n",
    "*Ornstein-Uhlenbeck* process generates temporally correlated exploration, and it effectively copes with physical control problems of inertia.\n",
    "\n",
    "$$\n",
    "dx_t = \\theta(\\mu - x_t) dt + \\sigma dW_t\n",
    "$$\n",
    "\n",
    "Reference: \n",
    "- [Udacity github](https://github.com/udacity/deep-reinforcement-learning/blob/master/ddpg-pendulum/ddpg_agent.py)\n",
    "- [Wiki](https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OUNoise:\n",
    "    \"\"\"Ornstein-Uhlenbeck process.\n",
    "    Taken from Udacity deep-reinforcement-learning github repository:\n",
    "    https://github.com/udacity/deep-reinforcement-learning/blob/master/\n",
    "    ddpg-pendulum/ddpg_agent.py\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        size: int, \n",
    "        mu: float = 0.0, \n",
    "        theta: float = 0.15, \n",
    "        sigma: float = 0.2,\n",
    "    ):\n",
    "        \"\"\"Initialize parameters and noise process.\"\"\"\n",
    "        self.state = np.float64(0.0)\n",
    "        self.mu = mu * np.ones(size)\n",
    "        self.theta = theta\n",
    "        self.sigma = sigma\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\"Reset the internal state (= noise) to mean (mu).\"\"\"\n",
    "        self.state = copy.copy(self.mu)\n",
    "\n",
    "    def sample(self) -> np.ndarray:\n",
    "        \"\"\"Update internal state and return it as a noise sample.\"\"\"\n",
    "        x = self.state\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.array(\n",
    "            [random.random() for _ in range(len(x))]\n",
    "        )\n",
    "        self.state = x + dx\n",
    "        return self.state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We are going to use two separated networks for actor and critic. The actor network has three fully connected layers and three non-linearity functions, *ReLU* for hidden layers and *tanh* for the output layer. On the other hand, the critic network has three fully connected layers, but it used two activation functions for hidden layers *ReLU*. Plus, its input sizes of critic network are sum of state sizes and action sizes. One thing to note is that we initialize the final layer's weights and biases so that they are *uniformly distributed.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int,\n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, out_dim)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        action = self.out(x).tanh()\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    \n",
    "class Critic(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(\n",
    "        self, state: torch.Tensor, action: torch.Tensor\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = torch.cat((state, action), dim=-1)\n",
    "        x = F.relu(self.hidden1(x))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BC Agent\n",
    "Here is a summary of BCAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|\\_plot              | plot the training progresses.                        |\n",
    "|\\_target_soft_update| soft update from the local model to the target model.|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BCAgent:\n",
    "    \"\"\"BCAgent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        actor_target (nn.Module): actor model to predict next actions\n",
    "        actor_optimizer (Optimizer): optimizer for training actor\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        critic_target (nn.Module): target critic model to predict state values\n",
    "        critic_optimizer (Optimizer): optimizer for training critic\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        demo_memory (ReplayBuffer): replay memory for demonstration\n",
    "        batch_size (int): batch size for sampling\n",
    "        gamma (float): discount factor\n",
    "        tau (float): parameter for soft target update\n",
    "        initial_random_steps (int): initial random action steps\n",
    "        lambda1 (float): weight for policy gradient loss\n",
    "        lambda2 (float): weight for behavior cloning loss\n",
    "        noise (OUNoise): noise generator for exploration\n",
    "        device (torch.device): cpu / gpu\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        demo_batch_size: int,\n",
    "        ou_noise_theta: float,\n",
    "        ou_noise_sigma: float,\n",
    "        demo: list,\n",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        initial_random_steps: int = 1e4,\n",
    "        # loss parameters\n",
    "        lambda1: float = 1e-3,\n",
    "        lambda2: int = 1.0\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "\n",
    "        self.env = env\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.initial_random_steps = initial_random_steps\n",
    "        \n",
    "        # loss parameters\n",
    "        self.lambda1 = lambda1\n",
    "        self.lambda2 = lambda2 / demo_batch_size\n",
    "\n",
    "        # buffer\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size) \n",
    "        \n",
    "        # demo buffer\n",
    "        self.demo_memory = ReplayBuffer(obs_dim, len(demo), demo_batch_size)\n",
    "        self.demo_memory.extend(demo) \n",
    "            \n",
    "        # noise\n",
    "        self.noise = OUNoise(\n",
    "            action_dim,\n",
    "            theta=ou_noise_theta,\n",
    "            sigma=ou_noise_sigma,\n",
    "        )\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target.load_state_dict(self.actor.state_dict())\n",
    "        \n",
    "        self.critic = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target.load_state_dict(self.critic.state_dict())\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
    "        \n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "    \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # if initial random action should be conducted\n",
    "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.actor(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).detach().cpu().numpy()\n",
    "        \n",
    "        # add noise for exploration during training\n",
    "        if not self.is_test:\n",
    "            noise = self.noise.sample()\n",
    "            selected_action = np.clip(selected_action + noise, -1.0, 1.0)\n",
    "        \n",
    "        self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        \n",
    "        # sample from replay buffer\n",
    "        samples = self.memory.sample_batch()\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # sample from demo buffer\n",
    "        d_samples = self.demo_memory.sample_batch()\n",
    "        d_state = torch.FloatTensor(d_samples[\"obs\"]).to(device)\n",
    "        d_next_state = torch.FloatTensor(d_samples[\"next_obs\"]).to(device)\n",
    "        d_action = torch.FloatTensor(d_samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        d_reward = torch.FloatTensor(d_samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        d_done = torch.FloatTensor(d_samples[\"done\"].reshape(-1, 1)).to(device)        \n",
    "        \n",
    "        masks = 1 - done\n",
    "        next_action = self.actor_target(next_state)\n",
    "        next_value = self.critic_target(next_state, next_action)\n",
    "        curr_return = reward + self.gamma * next_value * masks\n",
    "        curr_return = curr_return.to(device).detach()\n",
    "        \n",
    "        # train critic\n",
    "        values = self.critic(state, action)\n",
    "        critic_loss = F.mse_loss(values, curr_return)\n",
    "        \n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "                \n",
    "        # train actor\n",
    "        # PG loss\n",
    "        pg_loss = -self.critic(state, self.actor(state)).mean()\n",
    "    \n",
    "        # BC loss\n",
    "        pred_action = self.actor(d_state)       \n",
    "        qf_mask = torch.gt(\n",
    "            self.critic(d_state, d_action),\n",
    "            self.critic(d_state, pred_action),\n",
    "        ).to(device)\n",
    "        qf_mask = qf_mask.float()\n",
    "        n_qf_mask = int(qf_mask.sum().item())\n",
    "        \n",
    "        if n_qf_mask == 0:\n",
    "            bc_loss = torch.zeros(1, device=device)\n",
    "        else:\n",
    "            bc_loss = (\n",
    "                torch.mul(pred_action, qf_mask) - torch.mul(d_action, qf_mask)\n",
    "            ).pow(2).sum() / n_qf_mask\n",
    "            \n",
    "        actor_loss = self.lambda1 * pg_loss + self.lambda2 * bc_loss\n",
    "        \n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "        \n",
    "        # target update\n",
    "        self._target_soft_update()\n",
    "        \n",
    "        return actor_loss.data, critic_loss.data\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        actor_losses = []\n",
    "        critic_losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:         \n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if (\n",
    "                len(self.memory) >= self.batch_size \n",
    "                and self.total_step > self.initial_random_steps\n",
    "            ):\n",
    "                actor_loss, critic_loss = self.update_model()\n",
    "                actor_losses.append(actor_loss)\n",
    "                critic_losses.append(critic_loss)\n",
    "            \n",
    "            # plotting\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(\n",
    "                    self.total_step, \n",
    "                    scores, \n",
    "                    actor_losses, \n",
    "                    critic_losses,\n",
    "                )\n",
    "                \n",
    "        self.env.close()\n",
    "        \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _target_soft_update(self):\n",
    "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
    "        tau = self.tau\n",
    "        \n",
    "        for t_param, l_param in zip(\n",
    "            self.actor_target.parameters(), self.actor.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "            \n",
    "        for t_param, l_param in zip(\n",
    "            self.critic_target.parameters(), self.critic.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float], \n",
    "        critic_losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "        \n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize\n",
    "We make the demonstration using the well-trained agent in advance. (The given demo.pkl is created using *03.DDPG* agent.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "# load demo on replay memory\n",
    "demo_path = \"demo.pkl\"\n",
    "with open(demo_path, \"rb\") as f:\n",
    "    demo = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 50000\n",
    "memory_size = 100000\n",
    "batch_size = 1024\n",
    "demo_batch_size = 128\n",
    "ou_noise_theta = 1.0\n",
    "ou_noise_sigma = 0.1\n",
    "initial_random_steps = 10000\n",
    "\n",
    "agent = BCAgent(\n",
    "    env, \n",
    "    memory_size, \n",
    "    batch_size,\n",
    "    demo_batch_size,\n",
    "    ou_noise_theta,\n",
    "    ou_noise_sigma,\n",
    "    demo,\n",
    "    initial_random_steps=initial_random_steps,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABsQAAAE/CAYAAADxMaZGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd4XFeZP/DvO0UzI02RbXXXOLGdRuKQEFoaIZQsdVl6XyCUXZayLGx24Vn4sbTQ+9I2QGgJdYEESID0kOY0pzh2Enery9IUae7U8/vjnHN1ZzwjjYol2f5+nsdPrLlz75y59448ud/7vkeUUiAiIiIiIiIiIiIiIiI6WvkWewBEREREREREREREREREhxMDMSIiIiIiIiIiIiIiIjqqMRAjIiIiIiIiIiIiIiKioxoDMSIiIiIiIiIiIiIiIjqqMRAjIiIiIiIiIiIiIiKioxoDMSIiIiIiIiIiIiIiIjqqMRCjJUVENonI/SKSFpH3LPZ4iIiIiIiIiIiIiIjoyMdAjJaaDwG4QSkVU0p9dbEHU01ElIiMi0jG/PmeZ5mIyGUiMmL+XCYi4lm+WUTuEZEJ89/N87Hu0UZEmkTklyKy2+zvC6qWf0xECp5jkBGR9Z7lLxKRh8zjfxORk6d5vYtE5F5zXPeLyCvN4+dWvUbGjOcfamzjr2ZZwPPYbhHJeta9zrPsVBG5VkSGRUTV2N6NIuJ41t1eZ+yXm9c9wfPYu0Vki4jkROQHVc9/XdX7mTDrn2mWP0tEbhCRpIjsrvF6N4jIkIikROQBEXmJZ9kFIlKu2v6bGhzXyWbZqPnzl+mOGxERETXOfC+5aLHHQURERDQX5rrGdVMsP7feNZQGt/9mEbl1tusT0dLHQIyWmrUAHq63UET8CziWek5XSkXNn7d5Hn87gJcCOB3AaQBeBOAdgA55APwWwI8BLAPwQwC/NY/Pdd1F4w2A5tmtAF4PoL/O8qs8xyCqlNppxrMBwE8AvBNAK4DfA/hdvXGa0OWnAD4MIAG9/+8BAKXULd7XAPBCABkAf6raxusABOuM80WebTzX83gBwM8BvHWKffBuz7qbaoz9HADH11ivF8AnAFxevUAp9ZOq9/RPAHYCuNc8Zdys98E6Y3ovgG6lVBz6nP2xiHR7X7vquPywkXGZZS8HsBxAG4DfAbiyzhiIiIiOSgytiIiIiKZmrmu411eqbxI213IOuYZCRGQxEKMlQ0SuB/AsAF831SUbReQHIvI/IvIHERkH8CwReYGI3GeqVPaJyMc821hn/jH8R7NsVETeKSJPEZGtIjImIl+vet23iMg289xrRWTtLN/CmwB8QSm1Xyl1AMAXALzZLLsAQADAl5VSOVP9JgAunId16xLtSyIyaPbXgyJyqlkWEZEviMgeUxF0q4hEzLIXi8jDZn/dKCIneba5W0T+XUS2AhgXkYCI9IjIr0z10C6ZQ7tLpVReKfVlpdStAEozXP15AG5RSt2qlCoCuAzASgDn13n+RwB8Wyn1R6VUUSk1opR6os5z3wTgl0qpcfuAiCQAfBS6srFhSqntSqn/xRTh71RMwPc1AP9SY9u/Vkr9H4CRBjb1JgBXKKWUWfcupdSPoEOyWuPeavYrACjoIHB1I2OealxKqTGl1G4zDoE+7idUP4+IiIhqO4w3KREREREtCfy+Q0TzgYEYLRlKqQsB3ILJypgdZtFrAXwSQAy6cmgcwBuhK4BeAOBdIvLSqs09FcAGAK8C8GXoCqCLAJwC4JUicj4AmJZv/wngZQDazev/bJqh3iwi/SLyaxFZ53n8FAAPeH5+wDxml221wYOxtWr5bNedynMBnAdgI3QF1CsxGUh8HsCZAJ4BXZnzIQBlEdkIvQ/eB71P/gDg91UVaa+B3vetAMrQlVgPQIdPzwbwPhF5HqArmURkrIGxzsSLROSgCe3eVbVMqv4uAE6ts52nmTE+KCJ9IvJjEVle/SQRaYGuYPph1aJPAfgf1K9k+4kJCa8TkdOneU/VPi26peJtUtU2EsD7AdyslNo6w226TPB7HoArZrje1SLiALgTwI0AtngWd4jIgAlFv2T220y2PQbAgQ77PjWTdYmIiJYSEblURJ4QPS/uIyLy955ll5ibseyyJ4vIjwCsgf7OlRGRD5nnzugmpQbHFhKRL4tIr/nzZREJmWVt5t/6MfNd6xYR8Zll/y4iB8y4t4vIs+dxlxEREdExTERWm+tsQ6KnEvm66PaFt5nrCyMAPiaeloYicrNZ/QHz/elVoqdz2D/Vdmc4rmeIyN3mRvK7ReQZnmVvFpGd5rvRLtEdhCAiJ4jITWadYRG5au57iIjmCwMxOhL8Vil1m1KqrJRylFI3KqUeND9vhQ5vqiuA/ts89zroAO1nSqlBU311C4AzzPPeCeDTSqltpvLlUwA2S/0qsfMBrANwInSbt6s9Fx+iAJKe5yYBREVEaiyzy2PzsO5UCuZ5JwIQ8z77zIWNtwB4r1LqgFKqpJT6m1IqBx0iXqOU+rNSqgAdnEWggzPrq0qpfUqpLICnAGhXSn3cVHftBPBdAK8GAFOt1drAWBv1cwAnQYd1lwD4LxF5jVn2FwDnmy9ATdBhZxOA5jrbWgXgDQD+ATpAjUCHMdVeBmAYwE32ARE5C8Az6zwfAF4Hfa6sBXADgGtFpNH98O8A1kMHjN+Bvjh2vHnd1dDtNP+rwW3V80boarpdM1lJKfVC6HPq7wBcp5Qqm0WPAtgMoBu6evFMAF+c4bZboYPbdwO4bybrEhERLTFPADgX+t+1/wfTZlhEXgHgY9D/DscBvBjAiFLqDQD2YrLd8mdnepOSp4p7Oh+GviloM3S76LOhq+YB4AMA9pvX64T+LqVEZBP0v89PUUrFoKvyd89ojxARERHVIHp6lKsB7IG+jrISk9MoPBW6i00n9M3yLqXUeeavdmqTiuBpmu02Mq7lAK4B8FUAK6CvcVwjIivMDcBfBXCx+W70DAD3m1X/G8B10NOerEL960ZEtAgYiNGRYJ/3BxF5qojcYO7uSEKHWm1V6wx4/p6t8XPU/H0tgK+Yu2DHAByErihaWWsgSqmbTegzBj2f0nHQ4Qyg55eKe54eB5AxlV3Vy+zy9DysW5dS6noAXwfwDQCDIvIdEYlD768w9MWaaj3QXxbsNsrQx8C7T7zHZC2AHrsPzX78T+gvK1MSkTXmLp6MiGSme74ZzyNKqV4b4gH4CnT1FpRSj0K3Afw6gD7zPh+BvrBTSxbA95VSO5RSGehA9O9qPK+itaAJFL8JHSjWvPhkQtysUmpCKfVpAGPQF8YaeY93KqXSpkXmDwHc5hnXlwF8XClVHZLO1BtxaMVbQ5RSBaXUHwE8V0RebB7rN8embEK2D0EHjTPd9jiAbwG4QkQ6ZjM+IiKixaaU+oX5vlI2F2cegw6e3gbgs0qpu5X2uFJqT53NzPQmpUa9Dvq7xKBSagg6sHuDWVaAvrllrfn3/hbz/acEIATgZBEJmlbH9dpMExEREc3E2dDXoj6olBo3N7jfapb1KqW+pvQ0FzP5vjPddhvxAgCPKaV+ZF7/Z9A3A7/ILC8DOFVEIkqpPqWUnRajAHOtbBavSUSHGQMxOhKoqp9/CuB3AFYrpRLQF8/lkLUasw/AO5RSrZ4/ERO0NDo2+9oPQ99la52OyTmiHgZwmqn4sk6rWj7bdaceoFJfVUqdCeBk6NaJH4SudnIAHF9jlV7of7gB6HnIoOeJOuDdrOfv+wDsqtqHMaVUrWCpemx7zV08UaVUdLrn19sMPMdfKfVLpdSpSqkV0PN7rQNwd511t1a9l+pzzVZkXYDK1oJxAGcBuEpE+j3b3y8i9UKvinHOkHfdZwP4nOi2nbZV4+0i8tpGNyYiz4T+UvjLWY7HCqD2OQToMc/23xgfdFVfzWCaiIhoqRORN4rI/Z6bhU6FvlFnNWrfkFTLTG9SalTFds3fe8zfPwfgcQDXmRZAl5rXfhy6Uu1j0DdZXSkiPSAiIiKau9UA9tS54Xg233Ua2W4jqr8zwfy80tzM+yrom/T7ROQaETnRPOdD0Ndw7hLd+vots3x9IjoMGIjRkSgG4KBSyhGRs6HnGJutbwH4DxE5BQBEJGFa2RxCRE4Rkc0i4heRKIAvQIdE28xTrgDwryKy0lwg+ACAH5hlN0LfWfse0fM2vNs8fv08rFuXiDzFVNQFoVtHOgDK5oLK5QC+KCI95j09XfT8ET8H8AIRebZZ7wMAcgDqhYR3AUiLnlciYrZ1qog8ZbrxTTHukIiEzY9NIhK2gaCIvERElol2NoD3APitZ90zzRjaodsN/s5UjtXyfQD/KCLrRaQZwKXQ5fRebwDwt6q7oJPQX4w2mz82/DsTwJ2m8u2ZImLH/kHoi2C3mTGKeX9N5uewTM7d0SoizzOPBUT3oD4PwJ/Ma2yEDkztawP67qTfmPUDZtt+AH67nar39CYAv1JKVVQZiojPrBs0wwzbtkwicqKIXGyOcVBEXm/GdZNZ/iwRWWve22oAn6k6LnXHJSLPEZEzzHGLQ7chGMXkZ4uIiOiIIbr19nehWwyuMC2BH4K+MLIPU99M4jXTm5QaVbFd6LnLegHAVKh/QCm1Hrqd47+KmStMKfVTpdQ5Zl0F4LJZvDYRERFRtX0A1tS4dgHM7rtOI9ttRPV3JkB/bzoAAEqpa5VSz4Gurn8U+vuf7aBziVKqB3rKi2+KyAmzHAMRzTMGYnQk+icAHxeRNPQ8Sj+f7YaUUr+B/p/5K0UkBX2x4uI6T+8EcBWAFHT/4nUAXmha2ADAtwH8HsCDZjvXmMeglMoDeCl0m7ox6Pm7Xmoen9O6IvKfIvLHOmOOQ/+DPAp9F8sI9J2/APBv5vXuhm4VeRkAn1JqO4DXQ/c4HoYOW17kGWv1PiwBeCF0OLPLrPM96DkzICLnSoPtED22Q7czXAngWvN3+yXk1dB3Lqehg8TLTFtB6yvQ+2m7ed+X2AUi8joRcSvrlFKXm23cCb1/ctABm9chrQVNi6N++wfAkFk0YPZTDMD/mNc/AOD50H2lR8zz1pr3ZMeSNeMFdBj1CbPNYQD/An28d5jXHqx6bQAY9rQO+IjZ3qXQxzGLyXlBYEKpV1a/J+M88/w/QH/Jy0L3vQb0RbyPARg0Y3svgFcppe41y8+ADk3HzX8frNqXU42rFXqOlCT0XfPHA3i+UsqpMUYiIqKlrgX64s0QAIjIP0JXiAH6O9K/mRt4RPSk6/Y7zgD0HKLWTG9SatTPAHxERNpFpA36+/SPzVhfaMYk0P8ulwCURWSTiFxobuBxoP8dL9fZPhEREdFM3AU97cVnRKTF3ED7zAbXrf7+NF/bBfS1kY0i8lpzk++roLsvXS0ineaG7Rbo72cZmO9GIvIKEVlltjEK/b2Q35uIlggxU+IQERERERHRPBCRTwJ4F/TFjyugq8h/pJT6noi8E8D7oW/82Q3gDUqp+0TkJdA3JMUBfEIp9XkR+XvoCeRXQk/U/k92fgoR2Q3gbUqpvzQwHve55uaYzwKwXRF+AeBDpvvC+6FvemmHvoDzbaXUf4vIadBh3knQ82L8DcDblVK9c9lPRERERICeYx7AV6HnXlfQ06XcC/395RzP897sfcx8r/oo9Dyrb4e+iffHSqlV9barlKq+Edo7jurtnwN94/UJ0Ddnv1cpdauIdAO4EvrmcIXJ72mPiMhnoedsTUAHdpcppb4z131ERPODgRgREREREREREREREREd1dgykYiIiIiIiIiIiIiIiI5qDMSIiIiIiIiOYCKyRkQydf6sWezxERERES0VIvKtOt+ZvrXYYyOiw48tE4mIiIiIiIiIiIiIiOioxgoxIiIiIiIiIiIiIiIiOqoFFnsAc9XW1qbWrVu32MMgIiKiKdxzzz3DSqn2xR4H8bsTERHRkYDfnZYOfnciIiJa+hr97nTEB2Lr1q3Dli1bFnsYRERENAUR2bPYYyCN352IiIiWPn53Wjr43YmIiGjpa/S7E1smEhERERERERERERER0VGNgRgREREREREREREREREd1RiIERERERERERERERER0VGNgRgREREREREREREREREd1RiIERERERERERERERER0VGNgRgREREREREREREREREd1ZZcICYizxeR7SLyuIhcutjjISIiIiIiIiIiIiIioiPbkgrERMQP4BsALgZwMoDXiMjJizsqIiIiIiIiIiIiIiIiOpItqUAMwNkAHldK7VRK5QFcCeAlizwmIiIiIiIiIiIiIiIiOoIttUBsJYB9np/3m8eIDovBlAOl1GIPY8GVywo37xiq+953DY+jWCoDAIqlMkbH8ws5PEzki9jWl8KekXGUy/N7fJRSGM7k5nWbR7NsvoR9Bycwskj7TCnlnotHGqUUsvkSxnPFxR4KER1Gtz0+fMT+niIiIiKiQ+WKJdz+xMhiD4OIiA6DpRaINURE3i4iW0Rky9DQ0GIPh45Qu4fH8bRP/xV37jq42EMBAOw7OIGnfuov2DmUOeyvdceuEbzx8rtwz57RQ5alnAKe96Wb8ev7DgAAfnLnXlzw+RuRLy7cxb5/+8UDuPgrt+D8z92Ir13/+Lxu+/pHB/H0T/8V/UlnXrfbqHJZ4cLP34hf3rO/7nNKZYVzP3s9fjXFc6rd+tgwXvi1W+AUSnMa318eGcDzvnQzCubi7qu/ewfO/ewNOPMTf8Fv7z8wp21bDx1IYuNH/oh9Byemfe7P7tqHcz97gxvevuybt+EbN8zvOXG4/OvPH8BJ//UnnPLRa/HDv+1ueL3t/WlccsWWOR9L6/Jbd+EdP9oCQAfcz/niTbh6ay8A4K5dB/GKb/1tQT/fREeTO3aO4HXfuxNf+etjiz0UIiIiIponn7xmG17z3TuwrS+12EMhIqJ5ttQCsQMAVnt+XmUeq6CU+o5S6iyl1Fnt7e0LNjg6uuwaHkdZAQdGs4s9FAA6JBhI5bB1f/Kwv9ZBU/F1YOzQ9z46nke+VMau4XEAwI6BNJLZAgZSCxcg9SUdnNQdR2tzEH3J+T0+j/anUSgp7B4Zn9ftNmp4PIedw+O4d++hYaQ1lM5h38Es7t831vB279g5gocOpLB/jufzgweS2D6QxthEAQBwYHQCT1u/HEG/YFtfek7bth7uTSJfLOPR/um3t2dkHH1JB1kTDm3rS89ovyym+/aO4tSVcSQiQTx0oPHP9Y3bB/HnRwawc2h+ztFbHx/GDdt1RehQJofHBjN4uFf/j909e0Zx9+5RVk0SzdJQWn92dg4vzr8pRERERDT/dgzo/1cdnVjYbjlERHT4LbVA7G4AG0TkOBFpAvBqAL9b5DHRUcoGPOP5pdHOrN+Mp28BKpdsC7daVVJpRy8bMMsGFnBcVsYpYt2KZrRGgpjIz0+VjGUDtoUM+LwGkvriaV+NMNKyY5xJGGiPz1wr3zLm3LDnSNop4rRVreiMh9E/T+Hk5Fin354NwjJOEaWyQrZQWrRjNxNKKfQlHTx9/QqsW9GMgXTjgZPdP/MVBveOZZEvlnFwPI/eMb3tjGOPrw4+M2zrSERERERERERER7nAYg/ASylVFJF3A7gWgB/A5Uqphxd5WHSUGkjpC9Q2AFpsk4HY4a9Yc0Ov1KEX6e2FcTuehRyXdwzRUACRpoAbiMyXPhMIDNZ47wuhkeBzNiFkf0ofn945HicblGRyRRRKZeSKZURDAXQnwu7Y56o/2fj7s20D07kiQkF/w+sttmS2gFyxjM54GB3xMPaOTN8e0uo1YWnvFKHpTHjPObvvbRCWdooV/yUiIiIiIiIiIjpaLbUKMSil/qCU2qiUOl4p9cnFHg8dvQbSplJiiVRGzCQkmKvxnA4ZalXaZNywzFbx6ODIVpYshEyuiGg4gEjQh+w8V4j1JiuDvoXWSCDWN4tzYb4rxDK5olslFg0FTIXY/OyzmYw1W9BzW2Wcoju24UzOneNsqbLHuSsRRlc87P6+mcm6vfOwv7P5ktv+sncs6wbbaU/wCUxWBBLR0vK9W3bimZ+5frGHQURERERERHRUWHKBGNFCGUxVtg5bbP3z3CZtKpmcvkBeKxSyLSQHUjp0GBnPLdi4AN1qLpMrIhYKoPkwVIjZqpvFa5moXzeZLWCiTrtOe1wOjufdCqmpKKXm7fxJ20DME0DZCrG+pAOl1Jy2D8ws/LWBaCZXdD+rSgGDM2hBuBjse+yKh9EZD2FsotDQsQQmw+ep2mo2yns+9Kccd5+nc2yZSHQk+MQ122rO90lEREREREREM8dAjI5Ztl3gUrkQPFmRdfiDGvuea4VC3sqR3cPjsPnHQrWpm8iXoBQQDQcQDvrndQ6xiXwRyawOABa7ZSJQf596z4FGzoeUU3T301yPU8YTkLiBWDiArkQEuWLZ3X9zYUOaRqr0ckXTMtEpukEu0Nj8Y4vJDcQSumUi0Ng5lyuWMJwxVZnz8Jnzng+9Y84hFWLu532J3BhARERERERERER0uDAQo2OWDYOWwtw5Sin0JR34BBjO5N0Q4HDJmJaJg6ncIRU/3oDwgf1JAECT37dgFWL29VtCATQ3+RuuqmmErbwJ+mVGLezm00BKH2dgcj6zav1JB37zpEYCLhu++H1Sd5uNqtUysSUUQJcJdeYauE3ki0g5RT3WZHbaijNvhZj3s2pbeS5VNuzriIXdfdfIOTdg3pfdP3NlKyKDfkF/MusePxsuVrdOJCIiIiIiIiIiOloxEKNjUrFUdqswvFUniyWZLSBXLGNjZwzA5EXxw8VWAeVLZYxOFKqWTV4Y37p/DABwck98zkFLo+wF+mgogEjQX7et4GzYgOHk7jj656n930z1Jx2c2BUHAPTWCTz6Uw5O6tbnQiOhiH3Ops7YnEOUjCcg8R6LrkTYHdtc2PDupO4YnML0FWeOCYczTqEitFmogHa2BlIO2qJNaAr40GkDsQb2XW/VOVouz+0ctfv75O44epOO+zl2K8RybJlIRERERERUy3uvvB9f/etjiz0MIiKaRwzE6Jg0Mp6Hvc68FC4E25DhjDWtAOoHJfNlPDdZdVXdkq+iQmzfmDuukQbns5r72PTrx8IBRJrmt2WiDQPOWLMMuWIZqezCH/v+pIPTV7dWjMfLzge22T5nBhViT17bipQzWdk1G3ZuqfFc0T1P7Bxi3teaLbv+GauXAZj+/dWaQwxYvDngGtWXdNwQ0VaINbLv7HPOXLsMhZLC8PjcwvHepIMVLU1Y19aCA6NZDKYdiOjgUynl7tO5nDNERERERItFRC4XkUERecjz2FUicr/5s1tE7jePrxORrGfZtxZv5HQkGErn8MU/71jsYRAR0TxiIEbHJHsxvaXJvyTmzqkOCQ73PGLpXBErWpoAHNrGLZMrorU5CADY1pdG0C84uTu+IOOyrw8A0VAQkflumZjMQgQ4bVUCQGMt7ObTeK6IdK6INcub0RZtQn/q0ODTVguuW9GC1uZggxViOuQ4fZUN0WYXqCql3P3vnbMrGg6gPRaCyNxbJtr1bfg73TnlFMp6PJ45zdqiTQs2p91s9ScdNwiLRwIIBXwYTE8fbtkw3O6fuVZm9iWz6EqE0ZUI48BYFmUFrF7WjGJZwSmUPZVii/97kIiIiIhoFn4A4PneB5RSr1JKbVZKbQbwKwC/9ix+wi5TSr1zAcdJRERESwADMTomDaT0henjO6JLo0LMXNzfvGAVYkUc3x4FAAxUV4g5RXTGwoiFAsiXyuiIhbGyNbIg4wImW7m1hPxoDvpRKCkUSuV52XbfmIO2aAirljUDWJiAz8tWAnYlQuhKhN05zSrGmLTPCaM7EWm4qqgtGsKa5c0V25ipiXwJylM56bZMbAog6PehPRo65HyZKbsPGq2As4Foxpkcz/r26IIfu5kaSDluq0QRQWc83FBVW9+Yg0QkiBM69Odzrq0h+5MOuhMR9CQi7mMbO/W2h9I5FE2p7FK4MYCIiIiIaKaUUjcDOFhrmYgIgFcC+NmCDoqIiIiWLAZidEyyF6aPb4+6F9kXkw0J1q1oQTwcOOwX+zO5Io5ra6l4be+yaDiAjngIANzqEmDu1SqNjg0AYqZCDACy81Ql1pvMoicRRqd5bwvdds+GSZ1xHXbVCjvs8ehOhNFdJzSrtU53IoweE1zO9jh5w2Fvy8SWkN8dU98c91lfMotlzUGsXt4MnwD90wQ+9thnTIVYS5MfK1sjc57L7HByCiWMThTcNpOAbpvYyOe6L5nVx9IEWI0c/6n0jmXR0zr5GQaADWauQm/AzZaJRERERHQUOhfAgFLKOwnUcSJyn4jcJCLnLtbAiIiIaHEwEKNj0mDKgU+AtSuakSuWkS/OTwXSbA2kdIVPU8CH7kRkzhfBp5NximhtCaIt2uRWy1npXBEtoUDF/Efd5uL8XKtVGmEvzEfNHGLA5DxSc9U7lkV3IuJW7jTSwm4+uRVi8TB6EuGa1VH9FaFZuKHgx7bnsyHmbCvEvOGwDqAKiAT9CPh97pjmXCGWdNCViOiKs1hoyrEqpSYDMUfPIRYN63NzIOWgbCcCXGJs0GrPMwDoiIcaa5k4psPN1uYgwkHfnD5z47kiUk4RXZ6ADQA2mUDMu222TFxcIvJ8EdkuIo+LyKU1lp8nIveKSFFEXl617E0i8pj586aFGzURERHRkvcaVFaH9QFYo5Q6A8C/AvipiMRrrSgibxeRLSKyZWhoaAGGSkRERAuBgRgdkwZSObRFQ2iN6LmyFrs6oi/poCuhw4zu1nDNuaXmS65YQr5URiwUQEfs0DZu47kiYqEAOmP6Yn5nPIxIkx/LmoPoXcA5xFpCfjTPYyCmlEJf0kF3axjhoB+JSHDBK8QmWyaG0ZWImHm6Ks+9fjMfWEdMB2IHx/PTzqNmq4pCAT/aoqFZhyjeseixldASCriPdSfCcw5F+5IOutzqw6krvfKlstvC0c4hFg0F0BUPo1BSGBnPz2ksh0u/p+2l1WVaJio1dYjXn3LQ3RqBiKBnjuG4DRt7EhF0t+qxNDf53UpCu22/Txb9d+CxTET8AL4B4GIAJwN4jYicXPW0vQDeDOCnVesuB/BRAE8FcDaAj4rIssM9ZiIiIqKlTkQCAF4G4Cr7mFIqp5SyxYg6AAAgAElEQVQaMX+/B8ATADbWWl8p9R2l1FlKqbPa29sXYshERES0ABiI0TFpIK3n94mGdSC2UPOIjU3k8fsHeg953Fb4ADp0mG3LxD0j4+58W7liCbuGxw95zmQbvMlKm8cG0ni0PwVAV+JEQwF02goxG9QlIugbW5g5xJr8PoQCfkSCOhCbmIdALJktYCJfcitlOuOhiv2slMK2vhSuuH03vn/bLvzpob45v2a1gaSDWDiA5qYAelptG0q9T51CCUPpHPqTDla0TFYLAlPPdTZZBaSf212n8mwqe0cmkC+WkXYKAIC2aAjjJoCKhScDsa5EBCmniIn87D8vAylncqzxqcfq5CcrNzNOEelcEdFw0A2apgs0veFTNl/CvoMTsx430PjvCW/bS6szHsZEvjRlJZZTKOHgeB49Zr3u1vCc5u2z4WVXIozlzU1o8vvQlQi7x9Qu74yFlsRcisewswE8rpTaqZTKA7gSwEu8T1BK7VZKbQVQXc78PAB/VkodVEqNAvgzqiaVJyIiIjpGXQTgUaXUfvuAiLSbm5EgIusBbACwc5HGR0RERIsgMP1TiI4+A6kcVraGETXVL7XmEbth+yAGUw7i4SASkSBCQT/GJvJYuSyCE7tqdlVw7RzK4H9v3YWnrl+BF5/e4z7+iy378ck/bMPTj1+BtmjIMx4HZ67VN/V3xSMYzuTx9esfw3NP6cL6thb8+r4D+Nr1j+GjLzwFF53cecjr5YtlfO7aR/HdW3bhaeuX43MvPx3vvfI+3LdvDJ9/+el42ZNXYuv+JLpbw8gV9PXUaCiAzngItz42jL/76i04rq0F173/fHcOMRvQ2bZvGzuj+O0DvXjXj+/BO88/HqevbsWBsSzu2jWCl25eCT1fsfadm59AX9LB09evwIUndrgt9xqRyRUQNRfsI036v3OZQ2x0PI/7943hM398FABwSk/cfV8D6RyKpTL+7/5efO36x7BnpDIwuemDF2DtihZM5IsoK73PMrkifnPvfmQLJXTGw3jJ5pV1X1sphWJZIWjef39qMvi0VTq37xzB6uXNeO1378DW/Um0hAJYvdwERiY0+5ef3YcLT+zA+y7aULGfnUIJf310UD83MRmo7h6ZDELv2XMQm7ri7rleLZMr4jlfugkfecFJ7jnZnQhjOJPDeK7ozh8GTIajV2/tw9OOW4HVyyPueJxCCRd/5RZ89EUn44JNHUhmC7h37yjOPaENByfy+M9fP4ShTA7Dmbw71q5EGLc+Puxuf2wij3DQj7AJQp3i5HHP5IoIB32IhSbPzX0HJ3DqykTF+ymXFW7fOYKf3LkHf3lkEM88YQUuOrkT37j+cQykc/jg8zbh7eeuh88nqOfnW/ahXFZ49dlr3MdueWwIb/3BFtx26YVoj4Xw4zv2AABe/7S1SDkF/OP378ZnXvYkbOiMVbS9tGw7S/s7pRYbDtogdGVrBP93Xy8+8PMHsGZ5MwbSOrzuSzq45Nz1eOPT11acD/W215OIwOcTt3WiDcRshVhXInzIuU8LaiWAfZ6f90NXfM123fq/lIiIiIiOMiLyMwAXAGgTkf0APqqU+l8Ar0Zlu0QAOA/Ax0WkAH2j0TuVUgcXcrxERES0uBiI0THhF1v24cYdQ/jGa58MABhKO9i8utUNCTK5Iv7wYB/u3n0QH33RKSiWyrjkh1tQrDFH0crWCG679MK6r/XLe/bjQ798AGUF7BoerwjE7AXqsYkC2qK6QukL123H6EQB61a0AABecFoXbnlsCJ+/bgc+f90OBP2CQkmP4+49B3HRyZ24YfsgvnjdDvzqXc9AU8CH9155H/74UD+ec3Inbnh0EOd/7gYEfD6c0hPHv/3yAfzw9t3Yuj+Jf3jyKrz1nOMAALFwAKuWNbvtE3vH9JxMmao5xOzF+Y+9+BT0tEbwozv24I8P9eOUnjh2DKRRKCkc3x7Faata3ff59esfR8op4vu37cbnX3E6Xn7mKnfZ5bfuQiZXxHuevaHm/hvPldzjYivEbHXPJ655BF985eaKNn5T+cj/PYgf37HXPW7ffeNZeMYJbQB0WHHHzgM44+N/RjpXxKkr47jsH56Ecze04+HeFC65YgsOjGWxdkUL/ukn9+LOnQfx4tN7cNOOoYo2f09eswyrlzcD0AHYa797J3LFEjZ1xXD7EyMYSufwt/94NhKRIPpTOXe/bl7diqevX4H/9/tH8Jv7DuD+fWO4+NQu/OWRQWzoiLnbfsf563HDo4P4yl8fwyvOWoVVy/RrFUtlPOvzN6Iv6SAc9OFkE/T1tEZw+84RAEDaKeCV374DH3zeJrzz/OPdMf/ugV48MZjB+5+zEf3JLHLFMnYOjyNk9ndnXIdqtlrQ2tQZh98n+NAvtwLQlWRvfPpavOfZG7Dv4AR2DY/j3r1juGBTB350+258/rod2NARRcopIJUt4ow1rVjf3oKnrV8BAGg3lUnZfAmRJj9e8a3bccGmdnz4BSe7xx0AWpr8biDWEQtjXVsLYqEAPvCLB3DPnlEUywrDmRya/D7cu3cUu0cm0NocxAtP78Zftw3ihu1DOLErhlNWJvCZPz6Kn9y5B23REOLhIFZEm/DB521yz3MA+OHfdqNUFYht708jXypjIOWgPRbCL+7Zj0KxjNc/bS2296dxz55R3LHroA7EUg5amvyIeYIvG+L1J3M4oSOGwbSD/qRT8bkZSFW2WnzH+cejWFa47pF+pJ0iljUHsb49iq54GB/93cO4a/dBfP01Z9QNxQbN9mwYd+nFJ6I1EkQspMfVa6oTuxMRPNybqrkNOnqIyNsBvB0A1qxZM82ziYiIiI4MSqnX1Hn8zTUe+xWAXx3uMREdDj+5cw96x7L44PNOXOyhEBEd0RiI0THh9p0juH6brqQpl/XcQ23RJrcSKZMr4Oqtvbhp+xA++qJTkHaKKJYV3vvsDXjeKV1IOQVkCyX8+t4D+Ou2gSlf608P9WPlsghWL2vGYDpXsWwwrS9QJ7O6Nd17fnYf7t83hkvOPQ6vf9paAMAJHTH88l3PwP7RCdy58yAe6UvhxK4YvvTnHRhK6e3dufMgHjyQRO9YFuvaWnDrY8N41VmrcdnLT8PNO4bwhT/vwL8/fxPOWL0Mb//RFmzvT6MzHsK+0QmM5+0cXQG88elrcfqqVjx4IInL/vQohjJ6+7FQAM/a1IHPvOxJOMtUrrU2N+FDzz8R77rgeFx51z78+r4DeMbxbbhpxxBGJwrue1RKh2pvO+c4XH7bLuwZqWzb+NsHepGcyNcNxNKeEMadQ6xQwh07R3DtwwN4pC+Fp6xbPuUxsLbuT+LErhguvfhEPPW4FYg0TVY7veBJ3ehPOljf3oJzTmjDc07udIMFW5FmA4rt/WlEwwH86t792NgZwzde92QcHM/jkiu2oC/puIHY6EQBt+8cQVc8jO39aXS3RjCeL2HvyASetCqBgaSDjR06kAv6ffjem87CG/73Tty7dwwfecFJeNu56zE6nkdTQFeUhYN+/MfFJ+Fp61fgH79/NwZSjhuIDWfy6Es6eMf56/GeCze4IWFXIuzOTXZgLItSWWH/aGX1z9UP9OLu3Qfx/udsxIA5pwZSDlabbXcnwsjkdIvCla2TVU4n98Rxz0cuwhND49jWl8KP79iDn9y5B+959gY37B0y5/yBMR0KFcsKoYAfv3rX2W5oZ8XNHH5pp4BIkx/7Rifw2GDGXW6PQ1sshL4xB+GAD9FwAIlIEFe/5xxc9qdH8b1bd6GlyY/2WAiFksKqZRG876KNeP6pXQgH/Ug5BTx0IImz1y2H3ye48u59uPWxYaScAoYzOdy0YwhnrFmGN5jPH6CD6+q5vmzVl60mzTgFHDRzmNn3bgMo3RYyXLG+DdxsC8Sv/vUxXL21D/f/13Pd59jzrdMEWMe3R/HFV25GsVRGWcE9L5RS+OQ12/C9W3fh3567Cce1taCWgVQOiUjQrbj7uyd1AwBKJujv88x1liuWkS+W3degBXUAwGrPz6vMY42ue0HVujfWeqJS6jsAvgMAZ5111tST2RERERER0ZLy4d88BAAMxIiI5oiBGB0TUlkdaJXKCtlCCcq0v/O2TOwdczCeL6FQKruB1doVzRUX8e/fO4bf5/V2/HVarvWOZbGhI4bVyyJ48ECyYtmgCR9SZq6m3SPj+PszVroVMV6rljVj1ZnN+Afz80/u3OsGbPbC+YGxLJa1NCGdK+KEjigA4LyN7Thv4+Skv1e85WwoBbzvqvvxwP4xZMwF/WgogFg4iHM2tGEoo7f3hAkjouEAmgK+igoZKxYO4pLz1uOS89Zje38aN+0YcrcJ6Pm+ykpX/3TGwzhQNe/YQNLB6EQeSqmalS2ZXME9LmF3DrGie0xmMj/WeK6IE7viuGBTxyHLnnViB5514qGPA5Ot7gZSuqXiYDqHf7rgePzzs05Ak98Hn0/cOdeGPKGnrbj52ItPwfNP7cLW/WN48ddvQ3/KwUklXRXkDUpaQgFc8danYuv+MTzdVE0ta2k6ZDze6iLLngNnrV1eUTFn2xH2J7PoG7MBTWUwm3IKGJ0owCmU3O30Jx13HqmuRBhK6fe2qTNasW5rcxPOXNuEM9cuw1A6h69e/xjyxbJbNTeUngyH1q5owdX/cg7KStVsmxk3gXTKKSLRXIJTKFfMl+aYQKw9GsKekQmMjOfdc2PtihZ883VnYiJfRCTor1slFQ8H8Yzj29yfX3P2GrzGnNfFUhkbP/JHN8iyr2mDLqdQcs/BAXOcx80+Gs+V3H3Yb0Iuuy/7kocGYl2JMESAA6P6ubuHJzA2UdAtSs17sr8f2mOV61bvOxHBhSd24Hu37kJfMls3EBtMO+iIhQ553O8TNDf53c+UPWfGc0U0BQ49/+iwuxvABhE5DjrgejWA1za47rUAPiUiy8zPzwXwH/M/RCIiIiIiIiKiIx9vBadjgr3wO5Evuhe0W0IBdy6dTK7ohhmpbMF9fiJSOdePfb6tsqqlL5lFT2sYHXFdqWPbvgGTFWKpbAFKKYxlC2htqT2fULWOWMhd3xuI2Qvsdk6qaiLizh/Ul3SQzk0GYlanuQD/xFDmkGVTsRV2aWeyQsyGKtFwAN2JsBvKADDhkoNcsYwxT1WZl53DDJisEHMKpclArCpgm8p4rlQxB1ajbFjan3QwlMmhVFboSoQRDvrduafazXxb9pgAcMO/leZYuEFWysFwJo+yqpxXyr7WM45vm3IuKO92LBuO2moiy61EGnPc8XgDHwBIZfUx6k86ngqxnNuW0J73I+M591jUsrI1AqX0+WiDLDuuwXQOHfEQfD6pO4ecrRBLOQW38spbVelWiJl9nSuW3RDNam4KTLnvphLw+9AWDbmfJwAVfx9MHRpA2s++Pc/7k447F1e/3ZdJ55Dj3BTwoSsexn7zebVVexWvl9btL6vfYy02cBtI1Q+I7TGoJeb5jNnjYN8TLSylVBHAu6HDrW0Afq6UelhEPi4iLwYAEXmKmRPjFQC+LSIPm3UPAvhv6FDtbgAf5zwYRERERERERES1MRCjY4INU8ZzJTcQ81aIjY7n3XaByWzBreCqDsRsJc54nQvH2byuGulORNzKDBuYKKXc8CGVLcAp6BZlrZHGKjI64iE3LLDByIHR7GQIs6x2IGZ1xsPIF8vuhXhv0NGZsIGYbm/YaCAWC09W2Fn277FwEN2tEfQlJwOsoUwOdlq2epVeteYQm8iXZl0h1uh8Y9U64zoosWFHT6Jy/y5rbkLAJxUVYjactMdiRTQEv08wkHTcY9ZVFZQ0orU5iKaAr2Zw0xGrbs2nf+5LZt19318Vmth92ZvMutsZSDlIZQuIhoLucVUKU+4/G8IeGMu6rzHoacHYGZv6vcbNHFupbAEpM6aD43nkijoIyxXKAHS1oTVVQDcbnfFwRQWd9/yqCCDN3zO5IpRSbjDWm8xOhoEpB6WywmA6V/M4r1oWwYGxCZTLyv3cVh7THDpi4YYCvi73OE8RiJnt1WLnN4uGAoh55lKkxaGU+oNSaqNS6nil1CfNY/+llPqd+fvdSqlVSqkWpdQKpdQpnnUvV0qdYP58f7HeAxERERERERHRUsdAjI4JtiImkytiPKcvtreEAmhu8kMEeHwwAztlUNJTIRafYSBm5wda2RqpaLtnX9tWvKScIsayui1ba3OjFWJhjE0UkCuWMGAugveOZd3KtpV1KsQse4H+icHxivcCTFYtuRViDYYO0aYARCorxOzfY6EAekxVmp2Pqb8ibKhd6ZV2JivEIp45xGxFmTdgm4oNLVqaZhuIhSsqn6pb4Pl8gvZYqKKiqXcsi3DQh2XmmPp9go5YCH3J+ttphIigKx6u2H+D6RxEgLZoZaDaGdet+fo8lUtD6Zw7bxQw2bKzP+m4gW2xrLBnZAKxcKBin8WmDMTC7vu2YxvO5FAolTGcyR1SvVYtEZlsmZjyhKo2VLOfl4pALNTY56VRNvi0vOeXDcS8YXbGKWIiX3J/X/QnHfR5QsWRTA7FsnKDSa+VrRHsH81iMJ1DoaTcdazBtDPtPrOamwKIhwMV54SXUgpDU1SI2dA5Fg5M+3uNiOrjZGxERERERERERw4GYnRM8LZMzLgtE/W8Q9FQADsGMhXPrdcyMWra72VyJdRiw6nuRNgNmSbbHE4GJ8lswQ14WiONt0wE9NxD46YN44ExXSHWFPBhRY25p7y6Enr9x03o5Q09oqEAWpr8k3OINVhV5fMJok2BijDD7t9YOICe1ghyxbI7J5P34n3vWO0L+d45xEIBH0R05Z09JvUCgGrZgp7LbLYVYl2mcsgGJNUVYoAOairmEEtm0dMaqajwscGaDT6qW+nNZDzVFUtt0dAh7QibAroNYN+Y456PZQWMmArIUlm5VXx9SaeiLeDjQxldOekJRBupEOsdy7qVSsWywuODGT2P3DTvtVaFGDAZRNl2o7ZlInB4KsS8oaa34soGz2lPmD2eK1ZUUumwU+/n0YkC9h6ccLdbbdWyZvQlHeweGZ98Dc/+H0zl0DGD86M7Ean7eUhmC8iXylNUiOn9GA0HJ1ufMhAjmrXZNW4lIiIiIiIiooXEQIyOevli2b2YrSvEKufQioUCbmUUYFommooye8HestUpGaf2hWM7X1ZP62TLRHvB2zvXVMoTiCUarBCzF9gfPJAEAAT9gl4zh9jK1og7t9V06+8czKC5yQ9/1fM742H0movrjQZigL6w7g0IbNii5xDTgYkNGbyBTq0L+YVSGU6h7L6+iKA56Ec2X8KY2+avsUDMnctsFnOIAUBHPIzBtJ6HKxL0Ix45dJ90VFWI2WPhZYOs/pSDoF+mDS7r6UyEq6qJcu45Vq0nEUZfykFvMuvuS7vvveduf9LBQNrB+rYWALqSzNtKFJj6XAgH/VjR0oQDYzrwW27e20PmHO2sMz7LO4dYylNlaM8Np3hohdhUFWuz0RkPV7Rp7E86iId19ajdZwOecy6TK1Wc7/sOTmAwnUOPqQh7YL9+77UqAVcti6BUVrhnz6j7mPdzMJBy6h7TmmNPhA9phzm5LX1e1tueDcTiYU/LxDq/14iIiIiIiIiIiI4GDMToqJf0VJ6M50ru3D/NTbZCIoBcsew+J2UqxJr8PoSDlR+RFrdCrPaF4wNjWYjoi+GtzUE0+X3u3EO2EifoF6ScApKmZWJ1FVo9NhR4cP8YAODkngR6xxzsH52Ytl0iMDnXVDpXrBlyeFurzSQQi4YDFS0T7UX1aCjgttSz8yX1Jx00BXzoNq0Uq1WHlYBumzhRKLkVRMOZHPKe41XPhKc15mx0xUMolBQe6U2hu7X2vE7VFWIHxpxDA7FEGANJBwNJBx2x8LTB5VTj6fe0nxxIOXWrzboSYbeN4emrE+b5Zv46z7HqS2YxkMrhtFUJ97FouPFADNDh767hDA6O5/GklXo7NhCbrtopFPChye9DKlus+JwOVFWIHd45xPS27XHsHXPQ0xqpqMjzVnGNe0J1ANi6PwmlgNNXtwIAHtinP5+1AjE7t9wdO0f0z60RNyjP5IoYz5dmVEHYHa/9OQImA/i6gZgJ99kykWh+KAD37DmIdZdeg8cG0os9HCIiIiIiIiKqgYEYHfW8AYC3ZaK90F/9X9syMR4JHhKCRKe5cNyXzKIjFkLQ74OIoCM+WUFkL1Af19ZS0ZaxtbmxiiEbWNkKsSevaUW+VMa2vnRDgZhtpQfUDhW6PBfiZxIixcJBtyoMmGy7FgsHJyvETCDWl3TQnQijOxGuOYeYe2zClYGYY1omhgI+KFU571I9k60xZxmImUBj6/5kzfmgAKA9FsbIeA7FUhlOoYThTM5tI2h1xsNI54p4Yni84fmhaumMh5Erlt3zZqoKse5EBDuHMiiUFDaboMbuM7u+T4BtfWnki2Wc0pNwKwZj4cqWidMFUN2JMLaaqigbrD3UmzJjnvr9ighiJlC1VZl+n7hjtUG1d560mYS1jeiomuuvP5VFl2l5aqu37Hia/D5kckU39G1p8uPRfv1ebSC2df8YAj5BW8uh733VsmYAwJbdo2iPhbB2RbP7GjY4n0mFWFci7M7ZVs0G8PVCSXtcvS0y6wX9RFSf91vC7x/oAwDc8tiw+9in/7gNZ/73n+uu7xRKuG/vaN3lRERERERERDR/GIjRUc9beeJtmWirvaKmLeKa5c2IBP26ZaJTqNkiz16Mr3fhuHfMcUMgYHL+KEBfcI8E/VjZGkEqW5zxHGIrWkLwCfCwCRuevGYZACBfKh8SwtRj5xGrFSrYypRQwIemQOO/GnSg4W2ZWHBfY0VLE5r8voqWiZ3xMLoTkZqVLe78Y94KsaAf43ldQbSxM+ZuZzq1qs1mwgYJ2UKp4phWPCcWglLAwfG8+36qj4Xd59t6UzWrhhplj09/ykGxVMZwpv58U92JMMq6kAxPWtkKn0yGOrbS7ri2Frdyr7s1jHYTlsaqWiZOFyj2tEYwYSq5bIXYI70piFTO/VVPPBJEyiki5RQQ9AtWtkbQb8KcbL4En8BtxQjMfyDWaSonbSDVn9Sf4a6EJxAzYfa6tmYdiJlz64SOqLufbfC4e2QCHbFQzUpAWzGZLZSwalnE/H6wgbn+74wqxBJhKIWKtp2WfWy6lomxcNCdT5CBGNH8+/ZNOzFi5tGs5cO/eQh//82/ub+PiYiIiGhh/Oqe/fjkNY8s9jBm7K/bBjA6xfdLIiKaGgMxOupVtkwsImNb6TVNziEG6IvViUjQzCFWqNnKsGW6QCxZOYeUd46pwXQOnfGQ+xpjWR0ANDc1NseV3ydoi4aQK5YRCwWwoTPqLrOt2KZjq8Bqt0zUy2IzbEmnK8QqWya2mDnKfD7R7fuS3rAh7IYNtv2fd12gMoSJNAUwnMmjVFY4sUsHYr0NXDicbI05uznEvBVzPXUrxHTYMJjOuWOqrtazAUe+VJ5R2HHIeMwY+pMOhjN5KFU/7Oj2jGH18gjaoqFDKsRO7IpXjLHTbD8aDiAU8CFgK8amCaC873d9exTRUADZQgkrWpoQ9E//T0w8HEDKfObi4SC64mF3zq5soYRw0I9I0F9RwTafbBXbQMpBrljCcCaPblMhNph2UC4rDKZyiIUDaIuGdMvEvA3EYu52TuqKu0FyveAzFPC7r7dqWXPFawzMokKs0z0nDv08DKYdREOBuoGmtzLW79O/hziHGNH8UNM/xWVbzHr/HSUiIiKiw+8Dv3gA371l12IPY8be+sMtuOSKLYs9DCKiIxYDMTrqparmEJvIFdHc5HcrOKJuIBZxw6pknUDMBgW1WiYqpdA7lq1or1dZIabnkNIVMQWMTRSQiDTVnJuqHts2sTMRrggiGmmZaMcD1K76sRfqZ9piMBYOVASEaadY0WavpzWMvrEslFLoTznoMi0TJ/IlpKouwKdrtUwM+txKnRO7dYjTX2feJC8bfM62oqg9FoI9NF1TVIgBev6pA3UCMW91WddcAjG3tZ/jtt+sF7B5A7yVrabaqWoOMVttB+gqqa64rR7UrULteTBdy0RvRVxXIuzuEztn3XTs5yHlFBGPBNGZCLsVWU6hhEjQDxFxj+NsW2DWs6y5CUG/YCCdw0Ay574PO4fcwYk8+pO6srElFKhomXhChw6lm5v8iEcC7mdoqkpAe37oCrHJ17BzmE0375pXtxuI1a4Qmypci4cn5xAD9OeEFWJEczODf84X3dhEHudcdj0e7k0u9lCIiIiIaIZ2j0ws9hCIiI5YDMToqFddITaeL1ZcVLcX/LsTkYoKMXvB2MsGBbUuHI9NFOAUKtsXdsRDSDtFZPMlDKVz6IiHEA8HkcoWMDqeR2tzY+0S3e2ZkKErHkYsHHQvZjcaiNlQpVbVT+cU1WNTiYUCFcFWJles2EaPaY84OlFAvlhGVzzsBgZ9VZUt4zVaJjY3BdxQcWVrBNFQoGa7xWrjc5xDLOj3YYWZB6q7dboKMQcHRrMQAToTlSGENwSbS8vEDreSKee22asXeNjXiQT9SESC6IiF3ZaAdq6uTV2TFYYd8dBk9aAnIAEaaZk4eU5FQwG02UCswfnS7OchZebt64qH3OpBWyFmxxMO+hqqOpsJn0/QEdPBtT0fe0zLRECHrwNpB53xEGI2EDNh6wYTiHUlwhARt/3iVJWAdh6xVcsiFSHnQMpBOOhDfAYVcN1xM0dfrQqxlOOen7XY3x329xwDMaL5U139XGv5f/z6Qbc6TD92uEdV6bbHR7B/NItv3PD4wr4wEREREc2rfQcncPFXbsFBtlEkImrIYQvERORzIvKoiGwVkd+ISKt5fJ2IZEXkfvPnW551zhSRB0XkcRH5qsykdIaoDlshlogEMZ7XF7NbPG30JivEdPXW2ET9CjH7/FoXjm2FUI8nPLEB1mDacSvEEpEgykq3V2x0/rDJ7VWGDStbIxBpPGixLdZqhRxTtVOcSiwcQCRxkJEAACAASURBVL5YRq6oQ4J0roiYJ0zsbg2jP6UDI0BXtXS7gVhlsGUrbyorxPwomomaWpuD6E6EawYA1eYaiAGT8391T9Mycci0TGyPhhAKVLZojDT53ZBjLhVioYAfy1ua0N9AhVhnPAwRve9FBF2JypaJPpmsbkpEgggH/e65YcNIG5jY1qL12DDWnoP2HO1suEIs4M4hFg8H0BkPI1csI5ktIFcoIxz0ueOJhmb2eWlURzyEwVTOnZuuy7RMBExFXiqHzpiuEBs38xD6BFjX1gJg8vyw69Q7XwAdhOn/Nrv7XAdiOXTEwjOqGI1HdEhYq2JyMF1/jjnAE3x6/stAjGhuBI19foczefzsrr148/fvWtCqsocOJDGR5+eciIiIaDYu/dVWbP74dYs9jEN85+ad2NaXwq/v3e92HiEiovoOZ4XYnwGcqpQ6DcAOAP/hWfaEUmqz+fNOz+P/A+ASABvMn+cfxvHRMSKZLSAc9GFZcxDjuRLGc5UVYt4qK7dCzCkiHqk/9463ZaJSCtds7cPvt/YCqGwhZ1uo7Rwax0S+hM54yN3u3oMTs6gQMy3ZzIXuVcsi6IyF3bmLplNdBeRlw53ZzCEG6FaJ+r+Fim10JyIolRXu2zeqx5CIuG0Eqy/kZ2qEWBFPeJmIBN35x6yUU0ChVD5kXOPuXHGzm0MMmAx1uuu0TAwF/GhtDmIwncPegxN153KzYdFcKsQA04IzqcMTEaAt2lTzeUG/D+3RkBtWdcbCGJ0owCmUdPAUCbrvyW3zVxWItoQCaG6anLurnrZoCEG/eAIx899ZVojZUKk/5SBbKLnHPxoKzPv8YVanqRDrHdPnlZ3nDtCh7WDaQUfcBmIlZMzvEBt+d5lKLbel6RRB1LoVOkRbu7zZE7rlMGiq0GZCRNCdiKA/5eD2J0Zw3179GVNKz3s2VcvE49ujaIuGsNHMRRgNBTiHGNE8K5cXuOxrCuO5Il74tVvx7p/et9hDISIiIjoiXXn3PoxNzH3eV6UUrt7aW/M6xlx84ppteMon/zKv2yQiOhodnquLAJRS3tsm7gDw8qmeLyLdAOJKqTvMz1cAeCmAPx6uMdKxwVZ7NTfpICtTFYh1xsMI+ARrVjQjEdHhRqms6laItYT8FZUU9+wZxT//9F4AQNAvWLO8uWLbAHDTjiEA+oJ5xLSAs3OIzYSt+LDbfc+zN2Aw1fgdQPYif60qsHBQhzuzmUMM0IFYWzSEjFOsqJDZvLoVIsAnrt6mxxAPY0W0CT4B/vBgH4bSOWwfSOOJwYxb4u+tSrL7C9AVYj2JCB7tTwMACqUynvPFm/DKs1bjA8/dhOREAVdt2Yu3nbMe4/minvNtDi32Vi2LIBYOTNnGrj0aws07hrB7ZAL//Kzjaz6nMx7GjoHMlEFJI7riIRwYy6I9FsKKltCU7+3t5633hF76dYfSOffz0BIKuBVZwGTFmG0PGTUtEKfj8wlOXZnAyT16frd2t4qx8TnEcsUyhjN5xMPBilaF2XwJYVNx553Tbb51xkO49fFhXHX3Xqxb0YyWUAChgA8+AS6/bRcKJYXOeAjjuSLypTIOjucRCwXQ3BTA+Rvbce6GNgCToeJUlYAv3tyDzkQY69pa3P8B6k/qKrSTzBx5M9EVD+PG7UO4emsfRIB3nHc83nrOccgWSlMGbD2tEWz5yEXuzy2hAA6Osw890XyyleP1DGfyGM7of/cOd8vEfFH/vrnXBudYOmEdERER0XxSSuGbNz6Bl2zucVvWLyXXPjyAd//0Prz32Rvw/udsXOzhEBEdcw5bIFblLQCu8vx8nIjcByAF4CNKqVsArASw3/Oc/eYxojmxAYBtdTieK1YEExef2oUnrTzfbWdYMnd0122ZGA5WzEv2xFAGAHDFW87GuhUtaG2eDLlshcYP/rYbAZ9gY2cMSc8dRfVeox63HZ0Z/2mrWme0/qplEbRFm9zwo9p//t1JWG/awDXKVohl3AqxyjnETl2ZwM8ueRr+9ar7kXKKaIs2IeD3YfPqVtzy2DBueWwYK1sjOKk7hu5EGC9si1ZUJTVXVYht6Iziqi37sHdkAvvHJjCQyuG2x4fxgeduwi/u2YdP/eFRPPOEtkPmMpuNf77wBPz9k1dN2cauIx7CbY+PoCMWwrsuOKHmc1Yvb0ZbNOTOhzVbZ6xZhhv+vAN7RiZw3DTH6W3nrnf/3umpdvLOj3fRSZ3Y2BUDoM+l2y69cLIFYjyM0YnGepD/4h1Ph8/so8mWiY1WiOljlMwWEI8EKubVcool9xj+vxefgvw830FndcTD+ndDvogrL3kaACDg9+Ft567HzTuG0BkP4Yw1y3C/uZA8kHLc4PiHbznb3c6mrhiaAj4c117/2ISDfpy/sR2AruRrizbhxh1D2D+WxXnm8Znobg3j9p0jeNkZKxEK+vCtm57A5bfu0u+rwbaVgG6VmWaFGNExp9E2j0RERERHiv2jWXzu2u34/QO9+NP7zlvs4RzC3ghsp0IgIqKFNaerxSLyFwBdNRZ9WCn1W/OcDwMoAviJWdYH4P+zd99hbpTn2sDvd6VdbXUvMdjGBptiasAhJJQApuNASDuQQBo5pMB3yAkJMS0QEkIJ5dACGNMDmGLAgI1tcMEF977u6/Xa3l68XV16vz80I0u76prRjKT7x7UX0tTHu1rt6H3med6xUso2IcQZAD4SQpyY5HlvAnATAIwdOzbV8ClPdDm8SkWMBa097n4tE62WguBcQAND2iQOKI42h5gF9SF3fe9rtaPQIvDtY4b2q9gZWFKI/5kyERU2a6AyZEAxKus6g+uTbZl4+lGDcf5xw3HGUYOT2k9VWmTFursvjrr+x5PHJH1MNWHR7Qwk+nr6zCEGAGcdPRQL/vgdtPe6g9+jWb/7Nrx+CZ9fxkwUqesKLQIlhRZcdtLX8I85OzBnawNaewLVcZX1XXB7/VhXE0hYtHS7+v2cUzGiojhuUmF4eSDxc+cVJ0RNwP1hykT85Mz036tuuWAC7G4fnv9yb1Lt9Y5SqhZrWnvD2oE+/l+nhW13ZEi7zzuvPCE4L1w8oa/7E0YNQJGlAMeOrEho39DXilohViACH2Icbh+GlSdXcZYKtaLx9+cfg28ePTS4/M4rTsCdV5wQfL6nKVCZ2NztipjM/s6xw7H+7ov6vf5jOWJQCTYf7MDRw8pw7ZnJ//79vwsn4uITRuKyk74GIQS+f/pofLq5HptqO5N6nxhWYUNrjwtSyqTmMSOi6KJVfUWa948VW0RERETa8CsXYXZ3Yp9nI+FNQ0REuSut0WIp5UWx1gshfgFgKoApUgb+IkkpXQBcyuP1Qoi9AI4FUAdgdMjuo5Vlkc47HcB0AJg8eTJHECimTocHowYWo6TIgv1tdvS6fSi3RU7ADAxJUEVtmVgUPofYvtYejBlSGrF9nRACf+xTAh963GQTYsPKbXj1l2fG3zCD1JaJXU4v/H4ZtTKrbws+IQQKLQLxiqbUCrGBJUUQQmD04FKcOmYQ5m5tQLfTg5JCCxweH3Y0dGHd/kBCLJD49KWdEEvE1FOOwICSQlx92hFRtxkxoFiThE5BgcC0y4/H6WMHRZ3XLJLRg0tQZClAVUsPOh0ejBwQuUIwVOB1mtzrEwAmHTEA2++/NOFWlaFz9Q0oKUShpQCjBpbg4CE7XF5/2lV1ibh40kg8cM1JcRPC6uu3sdOJ0RHmixNCJJUMA4AHv38y2nrcOGfCMBTEma8tkvHDysKqBb8xbgi+MW5I0scZUWGDy+sP3ECQ5PsSEQUkmkv+7jPL9Q0kBr1bMxIRERERERGZWeqT68QhhLgMwO0ArpJS2kOWDxdCWJTHRwOYCKBaStkAoEsIcZYI3J7+MwCz9YqP8kdwzqQiK3rdgZaJoXNUhQpNVg2I2jLRGmwPCAA1rXaMH5p4m8HQyrNkWyaakfrv6XZ60OMOfF8qYsy5laySYELs8DGvOOlr2FrXiZo2O3559jgAwMeb64MVY2qFWLTEp5YumjQS9199Ukarai458Ws4efTAhLe3WgowflgZ9jb3hLVM1Esy87YNCKsQC/yMxwwpwUGlQqykULc/U0EVxYX46TePQmGcuNUEq8Pji/oekqwTjxiI844dnlIyTEvq3G9s20GUPjMmnVj4SURERKSd+z/ZjhVVrUaHQUREKdBzpPEZABUAPhdCbBJCPK8sPw/AFiHEJgDvA/itlPKQsu73AGYAqAKwF8BnOsZHeaLL4cGAkkKUKXPk2N0+lEapHApNUEWdQ8wWSKxJKeH3S9S09cadzylURbE1ODAVOt9YtlKTX91ObzBRqGlCTKkQCv1eXXHyqODj6886CsMrbHhn7cHgstYeF3rd6bdMzCUTRpQHK8SiJXuNMCBCEnrM4FIcPGSHw+ML/vzNIPT1VK7ha9wM1HkJm7tdBkdClL3SyTld+dRyLN+TuUEVMybtiIiIiLLFyyv24aczVhsdBhERpUC3ET0p5YQoy2cBmBVl3ToAJ+kVE+WHf87dgdPHDsJlJ42Czy/R7QrMISalDPaQjtoyMYEKsTKbFX4ZqBLpsHvg8vqDc5AloqBAoFxJzg0yUWIiVWpioMflRbeSECu3affvOlwhdviYY4aU4utjB8HnlzhiUAlOGzMIn29vwoBiKwaWFqKl24UelxdjBpdqFke2O2ZEOeZWNkBKc1UmDugzhxgAjB1SiuZuF6wFIiMtExMVmuiNNl9cthrBCjEiw728Yh/OmTgs5f0r6zrhlxKnjB4UdRvJTBgRERERERHlsdwa0aO85/dLTF9ajQIBPPLDU3HRCSMABJJbHp8/uF20yiE1CSYEUBFlG3XfHqcXNa29AJBUhRgQGPjvdnqTnkPMjAotBSguLAi0THR5AGhbIVYaISEGANNvmAyJwMCemhA7/ajB6HF6gy0TyzLQMjFbTBhRHqwIGGCi6qbQOcTUn/GYIYFEptcvTZUQC33fyLXXljrHXVMXK8SI0qX+bVL/n6hFO5vTOu/UpwNzk9U8dGW/dX0nhmcLRSIiIiIiouwipcSOhm5MOmKA0aFkNf0nZyHKILsnUAFWXGjBn97bjDlbGwAEBtrD2p3FaZlYYbNGndNHTZT1uLzY1xZIiCVTIRZ6nkEl2d8yEQjMwdTt9KJLrRDTMOGiJkT6JsSGV9gwoiIwiP/1MYG74ScfNRjDym2BlokuH1smhpgwvDz42EwtE0sKLbAqv2tqcmzMkJLgejMlxMqLQt9DzPM91EK5zYrSIguamRAj0pV6Iw0RERER6cOhjAsREeWamWsP4oqnlmHJrvRupsx3TIhRTul1BRIyf7rkOIweXIJH5u0CEEimhLZJLCuKnCixWS0oLizAwBiVW2qSpdflQ01rL2zWAoxSqisSNaAkMI+YlpVURqootobPIaZhIqpU+VnFavN3xrjB+MW3x+H7p4/G8AobmrsDc4jlWlu7dBw9vCxYEWCmhJgQIhiP2jJRrRADgJJC8/yZCq0Ki9Z2NZuNHFDMlolEGtrT1NNv2fmPLsl8IBGwcyIRERHlqmue/Srlff1+ibfXHMDK6jYNIyIi0sbOhi4AvNEyXeYZaSTSgDqH1dDyItw6ZSI6HYEWfgNLCoOJFSB6y0R129B5jfpSB8W7XR7sa7XjqKGlUavJ4p0j2f3MqqK4EF1OD3qUhGRFjO9fskqUCqFY7SVtVgvuu+pEHDGoBMMrbOh0eCBl7J9zvikutATnVIv1+jZCRbEVRdaCYDXY8HIbipVEmDqHnBlYlfagQG6+ttRkMhGlpm8bwl+/vi7sucMd/27lZOf4crh9WL+/PeHt+x09Ny5DiIgojwkhXhZCNAshKkOW3SeEqBNCbFK+rghZd4cQokoIsUsIcakxUZOe0qkQ+2RLPe74YKuG0fSXbFvtSNj+mogodUyIUU5RK8TKbVZc8/UjcbTSyjBQIZbY/D8DSwpjViNVKK3Sel0+1LT1YtzQ5NolAsApowfh9LHRJ73PNgOKrehxedHtDCQgtWyZOKLCBpu1AEeHtPyLZVi5Lfi4zETJFDOYMCLwPRxYYq5kzoDi8CS0EAKjleSdmVomAofbreZi9eGIChuau1ghRpSMZIYzrn52edxtbntvM3Y2dsHvl/D74x/99llb8IPnvkJjZ5zfXQ6aEBFR7noVwGURlj8hpTxN+ZoLAEKISQCuBXCiss+/hRDm+sBBhlKngcgMXqARERkh90b0KK+FJsSslgLcccUJuHd2JY4YVBx2l1Cs6o7fnX9M1JaKgX0D18sddjcOtNkx5fgRScd58wUTkt7HzMptVjR0OtHj9EIIbRNRg8uKsOGei1Ga4DGHV4QkxHIwaZGOCSPKsWhns6laJgKBFqK97vCf1dghpahq7jFdQqzMZkVrjztHE2LFaO5mH2qiVIQOZ0iJiHcW747QQrGvDzbUYc6WBnh8/rAbQbw+P6yW/vexbavrBAD0uvUbvFlV3YZjhpeH/X0lIiIyCynlUiHEuAQ3vxrATCmlC8A+IUQVgDMBrNQpPCLdaVFxlqz6DgemL63GPVMnwZIjnY+IKH/k3oge5bVuJSGmJkIunjQSF08aGVhWFDr/T/SX/jVfHx3zHOq+S3a3wO3z4/SjBqcVcy4IzCHmQZczMG+X0Lh+P5nEFhNi0V116hHosLsxrMxcg5qXnzQKbT3usGVjBpcAMF+FmJos17IK0ixGDrDB7vahx8X594hSof7t29Pcg/fX16Z8HLfPDymBqubDCbS1Ne341jFD045RlcywybXTV+HIQSVYMe1Czc5PRESUAbcIIX4GYB2A26SU7QCOBLAqZJtaZRnloPoOR1Lbdzs9uP+TbZqcu7bdjgpbYcz56bPZn9/fjBVVbbjkxJH49jHDjA6HiCgpbJlIOSW0QqyvMltic4jFo+67aEczCi0CZ0/gH/+K4kJ0Obxo63WjwuCB9GHlRcHHHNQPd9KRA/HID0813dx11591FG69aGLYsjFDAi0TS0yWEFNfU7mYbB0xIJAoZdtEovTYI1RrVSqVXImI9A6t2X0mfTJhiR62LskBJSIiIoM9B+AYAKcBaADwWLIHEELcJIRYJ4RY19LSonV8lAHekPbTH26sRafdE3P7pxdVwePTptrqnIcXY8rjSzQ5lhn5EmjtTURkVkyIUU7p7VMhFip0WWkag+ylRRYIEZio9czxQ5h0ATBqYKAl5Seb61FRbOwdUGFziPFnk7WOHVkBABgakuA0A7UyLBd/70dUFAMAmrpcBkdClH2+2NGEL7Y3AQD8/v7r31pzIOFj6TG+EC2hxqEMIiLKRVLKJimlT0rpB/AiAm0RAaAOwJiQTUcryyIdY7qUcrKUcvLw4cP1DZh00+nwoKq5B//7zmb84Z2NMbf1+CJcxKWhtU8XFCIiMgcmxCinqC0TKyK0M1NbJpYVWdKqkBFCoFxpm3b+scnPH5aLfnn2eLz2qzNxw1lH4effHmdoLMWFFgxQfv5azmVGmXXuxGFY8L/n4ZiQOXTMQE2y5mZCTKkQ62aFGFGynB4/qlt7AUSez+ut1YknxJKpBks1oZXqVdADc7Zj0c6mFPcmIiLKDCHEqJCn1wCoVB5/DOBaIYRNCDEewEQAazIdH2XOH9/ZBKcynzxv/CMiIoBziFGO6XV5YSkQsFn753qtlgLYrAUo1WAgu8xmRbfLiwuO551iAGApEPjOscPxnWPN8f0YVmFDl9PLCrEsJoQIVomZSbktUCFamoPJ1hEDAhViLd38oEiUjmV7WtPaXyD5RFeyCa54x//bJ9tQ3+HACzdMDlv+4rJ9eHHZPtQ8dGWSZyQiItKHEOJtAOcDGCaEqAVwL4DzhRCnIfAnrwbAbwBASrlNCPEugO0AvABullL6jIibMiNa2+eXl+/LWAy7m7pRbrPiiEElSe13y1sbcOzICvzPlInxNyYiooRxtJhySq/Lh7IiS3Bi+77KbVZNKjvKi604sqDEdNUrFDC83Ibqll4mxEhzRw8rx/ihZVHfY7LZgGIrbNYCNDMhRpQwPd4J9JySoe+ho8X/yooa/YIgIiLSkJTyugiLX4qx/QMAHtAvIsoG93+6PWPnuuSJpQCQ9A1Fn25pANDAhBgRkcbYMpFySo/LGzPhVWqzoMyWfmXHtd8Yg1svmpiTg+K5YLjS+o0tE0lrN54zHgv+9zyjw9CFEAIjBtjQ1MWWiURm5fT40NYTO2l946tr+y3j1QoRERGRefn8Enuaug07/4xl1Xhj1X7Dzk9ElEksn6Cc0uP0ojzC/GGqsiIryorSf9n/+tyj0z4G6eeIQSUYUGyF1cKcP2mroECgIIeHln98xphgQpmIYnO4ffh0S33Gztfj8uK66auwta4TU08ZhSknjMA+Zd6yUAt3NmcsJiIiIiJKjozQDeDxz3fh2cV78cUfv4MJIzLfiegfc3YAAG4466iMn5uIkqdjU5G8wIQY5ZRed+x5o64+7UhNKsTI3H77nWMw9ZRR8TckojD/j+04iBJ278eVmL+tKSPn+nJ3C66dvir4/NMtDUobndTISCMxRERERKSbcdPm4JJJI3GeMvd6aMOh9fvbAQDN3U5DEmJElB3YqUwbTIhRTonXMvF35x+TwWjIKEPKijCkrMjoMIiIKIc1dGauvehzS/bGXJ/qByN+oCIiIqJc4vL6jA4hpgXbm4IJMSIiMgb7iVFO6XHGTogREREREREREVHu6XF6jQ4hYW+tPqBb1f6vXl2L2ZvqdDk2EVG2Y0KMckqvK3bLRCIiIiItVLf0n7/LLOzuxAaD2DqRiIiIzKjL6cHt729GrytzCS4jLou21XfpctxFO5tx68xNuhybiCjbMSFGOSVey0QiIiKidLm9ftR1OIwOI6pH5u2KuJwJMCIiIsoGzy/Zi3fX1eLVr2o0O6YenaI77O609vf4/Cntx6bXRESpY0KMcoaUEj0uL8psFqNDISIiohzmTnHwIlM6HZ6w59HmCuMcYkRERGRGet3C09jpxBOf79bseI8uiHwTUibxficiouQwIUY5w+nxwy+Bcluh0aEQERElTAhxmRBilxCiSggxLcJ6mxDiHWX9aiHEOGV5oRDiNSHEViHEDiHEHZmOPVt9uqUeq6rbUtp39qY6nHTvfI0jSk+6dycTERER5YP/eXsjnly4R7Pj+VNIRtW2Z7bLQK/Li2cXV8GXSrB9VNZ1wmvyG8OIyBz+s2o/DvWa83MqE2KUM3qU3tLlrBAjIqIsIYSwAHgWwOUAJgG4Tggxqc9mNwJol1JOAPAEgIeV5T8CYJNSngzgDAC/UZNlFNstb23EtdNXJbTtx5vrMWNZNeo7HJg2a4sp52No7naFPWfdFxEREVF/Tq/P6BDw/Jd7NTvWzW9twJurD8Tc5l/zd+Ff83fh0y31aZ1rR0MXpj69HE98oV2FHRHlpl2N3bj7o0rcOnOj0aFExMmWKGeok62WcQ4xIiLKHmcCqJJSVgOAEGImgKsBbA/Z5moA9ymP3wfwjAj0upMAyoQQVgAlANwA9JmZOw95fX6c/fAiNHUFkk3/mLPD4IjSx446RERERNp5a/UB/POakw07/5wtDXG3UW8ed3nTq+xq6nICALbW8eMGEcXmVt5v2k3ayYQVYpQzDleIMSFGRERZ40gAB0Oe1yrLIm4jpfQC6AQwFIHkWC+ABgAHADwqpTykd8DZYv3+Q2jojN2SZkdD9A/0nQ5PMBlmdgcP2cOet/ZpTRGtYoyVZERERJQvos21dc2/V2Q2kFzCu62IKAsxIUY5gwkxIiLKM2cC8AE4AsB4ALcJIY6OtKEQ4iYhxDohxLqWlpZMxmiYHzy3Et/51xJ02N2oau7GUwv3oKVPa8HLn1wW9nzW+trg3a+BIrzs0Ld6benuln5JMiIiIqJ8U9fuwNSnlwMAtjd0YUttZ79tNh7o0Ox846bNwR/f1b+9ttGXqYK3VRFRFmNCjHIGWyYSEVEWqgMwJuT5aGVZxG2U9ogDAbQB+AmAeVJKj5SyGcAKAJMjnURKOV1KOVlKOXn48OEa/xPMy+3145yHF+Oix5fi8c9340/vbe63zZ+VZV1OD257bzOun7E6uG82q+8IVMcdaLOjUUnyEREREeWTbmWcKJM+2ND3Up6ISFvRKl4pMbolxIQQ9wkh6oQQm5SvK0LW3SGEqBJC7BJCXBqy/DJlWZUQYppesVFu6mFCjIiIss9aABOFEOOFEEUArgXwcZ9tPgbwc+XxDwEsklJKBNokXggAQogyAGcB2JmRqLNIT8hAiMPjw5e7wyvk3ltfCwCQSv5rT3MPXF4fznpwYcZi1INa4XbevxZjymNfAjj8wUnPD1A+v8RrX9XAZYJJ64mIiCg75Uv9UUbHtDmATkQEQP8KsSeklKcpX3MBQAgxCYHBnhMBXAbg30IIixDCAuBZAJcDmATgOmVbooSoA14VxUyIERFRdlDmBLsFwHwAOwC8K6XcJoS4XwhxlbLZSwCGCiGqAPwRgHrT0LMAyoUQ2xBIrL0ipdyS2X9BlpFAU2eUaqmQkZfj7p6XmXh0VBBjJMnuDiSrVu9r0/y8szbU4t6Pt+Hfi/dqfmwiIiKiXNPS7YJLx84E0S4J6zocWLCtUbfzEhGZtZLNiMzB1QBmSildAPYpgztnKuuqpJTVACCEmKlsu92AGCkLsWUiERFlI+Wmobl9lv015LETwI8i7NcTaTnFEWVU4J21BzIbh85izS2xq7ELANDU5Yq+URLu/2Q7Zm+qw/p7Lka3M3A91uX0aHJsIiIiolz2jQe+MOS83316OQ71ulHz0JWGnJ+IcpfR8xzGo3eF2C1CiC1CiJeFEIOVZUcCOBiyTa2yLNpyooT0KAMwpYUWgyMhIiIiM5KQEfNhe1t68M+5ud9t0uHxoaa1V/PjvrxiH9p63Zofl4iIiKivv86uxK0zN0ZcJ0w2Cuvzxy6PeGnZvgxF0t+hGlkYpAAAIABJREFUJK/dTFroQUSUtLQSYkKIL4QQlRG+rgbwHIBjAJwGoAHAYxrEq573JiHEOiHEupaWlvg7UF7ocflQVmRBQaweQURERJS3vH4ZcaBEnWMrlwgh0B2hSuv8R5foel5p1r4YRERElBNeX7kfszfVa3rMsx9ahA579ATRyr2ptZl+auGemOvnbG0Ie/6TF1fD4Tb3PKwccSOibJdWQkxKeZGU8qQIX7OllE1SSp+U0g/gRRxui1gHYEzIYUYry6Itj3Te6VLKyVLKycOHD0/nn0A5pNflRTnnDyMiIqIoNh7oyJsP8QLABY8al+gTefOdJiIiIq05PYnNqeVw+zD16WXYdLAjrfPVdTiwvKo16vrrXlyV0nF3NHQlvc/LK4yrGiMiyge6tUwUQowKeXoNgErl8ccArhVC2IQQ4wFMBLAGgcngJwohxgshigBcq2xLlJAel5fzhxEREVFMt7232egQMmL2pnq09kSeIyyTNVyPzt+FdTWHMnhGIiIiynZqUihe5fm2+k5U1nXh759uBxBog22Ug4fsmhzH64t/pZbKjUdSwyvAldWpVcwREZmBnnOIPSKE2CqE2ALgAgD/CwBSym0A3gWwHcA8ADcrlWReALcAmA9gB4B3lW2JEtLj8qKcCTEiIiIivPpVTdR1r6/cH3y8bI8+7cfVzpTPLK7CD59fqcs5iIiIKPfsbEysqmprbSfa7YH20Pvb7Ljno0r8yKBrjsq6TvzilTWGnDtRZm/FSES5x6zd9HXLHkgpb4ix7gEAD0RYPhfAXL1iotzW6/KirIgJMSIiIqJE3fDSGtQ8dKVmx1M/9LBhIhEREaWiw95/DtRIvvvM8uDj1h4X3li1P8bW+nF6fJj69PL4GyaoSqcqt/s+2Y5fnD1el2MTEWUTPSvEiDLK6fWhpMhidBhERESUYR6fHwu2NRodBhERERHppMPuRrczsWRZKlp73Cnt5/ElNt9Zoj7ZXK/p8UJd+sRSLNrZlNQ+fr/EKyv2weVhhRlRNvrX/J246hntkva5gAkxyhlOjx/FhXxJExER5ZsnPt+Nm95Yr1v7v1jeuPHMjJ9Ta3tbevDYgl0x5+lYvz+xecC0nJ+CiIgoHiHEy0KIZiFEZciyfwkhdgohtgghPhRCDFKWjxNCOIQQm5Sv542LnJJ12v2f4/S/f250GBkRb+60VO1q6sa0WVuT2ueTLfX42yfb8cTne3SJiYj09ezivdhS22l0GKbC/nKUM5weH2xWVogRERHlkwseXYJ9rb0AgEO9bvS6vBm9Ay50vGLZ7Regy+nBgTY7XvmqBmv2JZZEMtqUx74EANxw1lGoKC6MuM0PnktuTg7BnolERJQZrwJ4BsDrIcs+B3CHlNIrhHgYwB0A/qKs2yulPC2zIZJWPD7z3XijR6vG2Zu0qRJbVd2G99bXpnUMuzL3WIcjtQo6ItKe+d4JIzPrZ0KW01DOcHlZIUZERJRv1GSYanNtB/a29EbZWnv+kIzYmCGlOPGIgbj85FEYO6Q0YzFoxeX144S/zkvrGGadOJmIiHKTlHIpgEN9li2QUnqVp6sAjM54YJSzmrqcYc8fmbdL83Ps1WgesWunr9LkOKHMOsBNlA/4+6cNVohRzmCFGBEREelNCOC4kRXY2dgNIJAA2nzvJTh4yB623eDSyJVWZubQYG4INR8m+GmNiIjM4VcA3gl5Pl4IsRFAF4C7pZTLjAmLstWvX1tndAhERJQGJsQoZ7i8fthYIUZERJTXBPRJxMz42WRMOWFEMNHzxfYm/GXWFpw+djAGlhRi4JEDw7a/7ZLjUFAg8O7ag7j85FEot1lx8wUTcOrfFgS3+cW3x+HVr2p0iddoTIcREZHRhBB3AfACeFNZ1ABgrJSyTQhxBoCPhBAnSim7Iux7E4CbAGDs2LGZCpn6MGPl+da6zM7F84eZG3HLhRMzes5EmfDHYwgpJT7eXI/LTxqFIivHJYlUZnwPB5gQoxzh90u4vX4Us0KMiIgob83f1oi5Wxs1O96wchvW3X1RxHUXTRqJ9ZMujrpvcaEFd1x+Au64/ISw5defNRb/WXUAAHDfVSfivqtOxLhpczSLOR1MYhERUa4QQvwCwFQAU6QMDMlJKV0AXMrj9UKIvQCOBdCv5EdKOR3AdACYPHmySYf0clOkAdTfv7k+84GYxEeb6rGvzR5/Q52ZdWDbDBZsb8KtMzeh6sIe3HbJcUaHQ0RxMG1NOcHl9QMAK8SIiIjyiM8f/sk83WTYe7/9Vtjz1XdOSet4kfzjeyf3W/bID07R/Dyp0GKcg4MlRERkNCHEZQBuB3CVlNIesny4EMKiPD4awEQA1cZEScnQ8oanfJdsV2veMBVfh90NoP/8ckRkTqwQo5zg8gbmvGCFGBERUf746+xKTY/3jXFDMGnUAGxvCHROshToMwTw3E9Px3Ffqwg+P2PcYF3OYyiOnhARUQYIId4GcD6AYUKIWgD3ArgDgA3A50qr41VSyt8COA/A/UIIDwA/gN9KKQ8ZEjhRluE9T0SUK5gQo5zg9AQqxIoLmRAjIiLKFx9trNPsWKePHaTZseK5/ORRYc/HDy0LPn74ByfjL7O2ZiyWUFrksCSHS4iIKIOklNdFWPxSlG1nAZilb0REh/XtZmAGsebbrW23Y1BpEUoKLfjn3B246byjI+xPRJTd2F+OcoLTE6gQs3HySiIiorwhku35EsMHvz8bAPDMT74OADjxiAGaHTuegpBKtP/6xtiMnTeeug5HxOVPLdwDGaU3oro41mALERERUT7wmjAhFss5Dy/Gj59fiRVVrXhp+T5Mm7UluI5tsYkoV7BCjHKCOocYK8SIiIgoWYWWw8mbo4eXY/v9l8JawJtspj61LOLyxz/fjUtOHInjvxY9aahhrpKIiIjy1GOf78ZlJ33N6DAyLt5lVGOMuaqi3bSUqO0NXfArx/CFHSrwRMsb0ogot5k1j85P+pQT1Aqx4kK+pImIiPKFFh/H7/vuJMz/w3lhy0qLrCjKcNX5xZNGZvR8iWi3e6Kue/KLPdhW35nBaIiIiCgf/X3ODqNDMKUelzel/ZLNZxmV/5qxrBq/fGWNMScnorSYPW/OCjHKCWqFmM3KCjEiIqK8kcaFds1DV2oXhwae/cnp6E1xYEMrydzB91llI+Zva0T1g+b6PhIRERFRbC6vz9Dz13U4cOSgkpjb/IOJUCLSCctpKCewQoyIiIgSFWmCcKMVWQswuKzI0BheXFqd1PZZNi0GERERZQFp2iZbuaGh04nj7p4Xcxs9fwJf7m7B2Q8twtytDTqehSi3pdsaNd8xe0A5QU2IsUKMiIgof6RaIHblyaM0jSNXvLe+Nul9Fu1sCnuufjgzeZcMIiIi0tl76w5iRVWr0WFQGtK5nvP5JTYeaO+3fHt9FwBgc21HGkcnyk+Cn7I0wYQY5QS1ZSIrxIiIiPJHKpN6nztxGI4fVaFDNPqoeehK07V3DPWrV9dFXG72vvFERESkrz+/vwU/nbE67eOwEkJfD36WWGvCZH8Mzy6uwjX//grr9x9KISoiymZmf9tm9oBywuGWiawQIyIiyhfJJl3e/c238MaN38yaivK7rzwh+Pj7Xz/SwEgSZ/YPP0RERGQebq8fXp8/bBkrIBIzPclW19G88KU2x+lrZ2OgEqyx06XL8YmIUmU1OgAiLagVYjYrc7xERET5osPuSWr7M8cP0SkSba2YdiEGFFtRUVwYXHbk4NgTj5sNB7OIiIgonmPv/gxjh5Ri6e0XAAi02bvuxVUGR6UdPSvmn1q4R7+DR7jBKdV7nm5+awNq2o7DzRdMSCskIsoeZu8WwuwB5YTgHGKsECMiIsppte12jJs2Bwu2NSa13+ybz9YpIu0dOagkLBkGAOW27LiPbdNBzgdBREREiTtwyB587PL6DIzERPqMJu9p6jYkjC93twQfH+p1AwD2tfYmfZx/zd+FA232+BsSEWUAE2KUE1ghRkRElB+21nYCAGZtqE14n2W3X4BTxwzSK6SM+OXZ48NaKJrVwp3NRocQ0dbaTpxy33y09rBtDxERUTbpdXmNDiFlWhVJ2N3mSRTWtqeW2Npcy5umiMzA55dYuKMpr+dnZPaAcoLL44MQTIgRERHlOvWG2WQqkczesiERRdYC/Prco40OI6Z31h4IPjbb93z6smp0Ob1YUdVqdChEREQUwROf78YdH2ztt3zDASZSiIi0MmNZNW58bR3mJ9lxJZdkR+8VojicXj9s1gIIs42+EBERkS6auhKv9BlUWqRjJKT6y6zDg1i8IiMiIqJkPKnnnFgGMaL+4s4PK9M+hgyJPNa8sNlaYCKlxMFDDowdWmp0KEQZV9vuAAA0d+dv5wyW01BOcHp8sFk5fxgREVHuSy7VsueBy7Nm/q1kvf3fZxkdAhERERGZyNtrDsTfSCNunw/PLdkLj8/fb12sRBoAY7KFijdXH8B5/1qM9fvbjQuCkvLckr147asao8OgJO1o6MI/5+4wOox+mBCjnODy+FFcyJczERERhSu05O71wcmjBxodQnRCZPWcH0REREQU24xl+/DwvJ14feX+hPcxQ2OnDQcCibB9rb0GR0KJenjeTtz78Tajw6AUTF9abXQI/eTuCAHlFafXh+JCVogRERHlumQ+RK+840L9AjFYzUNXmr7yzUx96fN50mgiIiLKMlly3dLr9gEAHO74N0GZIRFGua+9141zH1mEXY3dRoeS1+JWiBpMt4SYEOIdIcQm5atGCLFJWT5OCOEIWfd8yD5nCCG2CiGqhBBPCU4IRQlyeQJziBEREVFuS/TicOffL8OogSW6xmKE1391Jt648Uyjw0jLop1N+HRLvSHn5scLIiIiypRUrzpW7TukaRxE+WLRzmYcPOTAC1/uNToUXfCjjDZ0yyBIKf9LSnmalPI0ALMAfBCyeq+6Tkr525DlzwH4bwATla/L9IqPsp/X58fmgx0AWCFGRESULxJNaOTqdcF5xw7HuROH91t+7sRhBkQTXayf0q9eXYdb3tqIhk5HxuJRsVKMiIiIMmXxrpaU9nN5+8/JlUlhl0t9LuoSqfz41/yd2FzbEXe7bfWdOPauz9DY6UwyQiIy0hOf78aDJpwbLFG6l9QoVV4/BvB2nO1GARggpVwlA59UXwfwPb3jo+w1f1sTrn52Beo6HHB6fKwQIyIiorz1+I9PMzqEMELEv4PxWw8uylhSjJVhRERERImJdf+QRP+VHXYPvL7DSbxnF+9FbXv8a7w3Vu6H2+fH4l3NKcVJlEuklHFv3jPLvX1PLtyDF0w4N1iiMpFBOBdAk5RyT8iy8UKIjUKIL4UQ5yrLjgRQG7JNrbKMKKJDdjcAoLnLCZfXn7N3ghMREdFhiaQ1Zt50lu5xmM3wChuuOvUIo8NIWluPOyPnYWUYERERkcaU66sZy/fhntnbYm568JADc7Y0ZCIqoqw0Y9k+jL9jLjrtHqNDyXlpzcQthPgCwNcirLpLSjlbeXwdwqvDGgCMlVK2CSHOAPCREOLEJM97E4CbAGDs2LHJB045walM3tlh98Dp8WNoGRNiRERE+W75Xy7A6MGlRoeRMWvunIIGE7aZMetEyqwUIyIiIkpd4BovkAjbXNsZXP7p5no8+P2To+738LydAIC/XHa8rvERZau31x4AALT0uDCwtNDgaHJbWhViUsqLpJQnRfiaDQBCCCuA7wN4J2Qfl5SyTXm8HsBeAMcCqAMwOuTwo5Vlkc47XUo5WUo5efjw/nMoUH5weAIJsXa7Gy6PD7ZCtkwkIqLsI4S4TAixSwhRJYSYFmG9TQjxjrJ+tRBiXMi6U4QQK4UQ24QQW4UQxZmM3QjN3a6Y6/MpGQYAIwYU49QxgwAgQgMbY0VKin2xvcmASIiIiIgoUTGvKbW6tyjB46yoatXohESUKWa/B1HvDMJFAHZKKYOtEIUQw4UQFuXx0QAmAqiWUjYA6BJCnKXMO/YzALMjHZQIAOwhFWIurx/FVlaIERFRdlGuiZ4FcDmASQCuE0JM6rPZjQDapZQTADwB4GFlXyuA/wD4rZTyRADnA8j5/gp3frg16rrNf70kg5GYT1lR4FroiIHF+M6xxt40FulD0I6GLvz69XWZDyaK99YdxGMLdhkdBhEREVGYzQc7jA4hSLdx7QTv5PrpjNVh85NpGgJbalMeijQPoObnMPmvlt4JsWsR3i4RAM4DsEUIsQnA+wgM4hxS1v0ewAwAVQhUjn2mc3xZ6b6Pt+G9dQeNDsNwTo+aEHPDyQoxIiLKTmcCqJJSVksp3QBmAri6zzZXA3hNefw+gCnKzUOXANgipdwMAFLKNimlL0Nxm875xw3P+9YSd115Am67+Fgs+8uF+NU54w2NRSA8KfbKin3odnoNi0cVOvDx5/e34OlFVQZGQ0RERJRf1OvDF5ZWJ7yP1mPrZm3tTekzeR6GTELXDIKU8hdSyuf7LJslpTxRSnmalPJ0KeUnIevWKS0Xj5FS3iKZqo9oXmUjFu9qNjoMwzncastEVogREVHWOhJA6F0utcqyiNtIKb0AOgEMRaDltBRCzBdCbBBC3J6BeE1rZEXOd4uMq6K4EP9vykRYCgQGFKc1VbDm/vbJdqNDICIiIqIkJTowywFcMpVszHlm6JeICWH9K8RIBx6fH52OnO+IFJc6h1iHwwOnx4diVogREVF+sQI4B8BPlf9fI4SYEmlDIcRNQoh1Qoh1LS0tmYwxY353/jFGh2AqXx87GM9ff7rRYcTl8vowfele3Vrh9CXM3tCeiIiSIoR4WQjRLISoDFk2RAjxuRBij/L/wcpyIYR4SpmXdYsQwvx/KIkMEKs+wYgrKbOWS/j8Ej6/SYOjrMWPK/pjBiELuZkQA3A4Idba7YLXL2FjhRgREWWfOgBjQp6PVpZF3EaZN2wggDYEqsmWSilbpZR2AHMBRBzYkVJOl1JOllJOHj7c2Lml0rHhQHvUdeOGlWUwkuxw2UmjjA4hTKQPd88sqsI/5+7ErA21/VcSERHF9yqAy/osmwZgoZRyIoCFynMgMGfrROXrJgDPZShGIopg5trsng7mpHvn47xHFhsdBhEliQmxLOT1SXQ5jJ+DwWjqHGJNXU4AYIUYERFlo7UAJgohxgshihCYf/XjPtt8DODnyuMfAliktJWeD+BkIUSpkij7DoCc7ks3Y1nkuQae/Qlv8I7mhrOOMuS8Ty+ugtsbXvW1JELL7x5X4JpWbYVNRESUDCnlUgCH+iwOnX/1NQDfC1n+ugxYBWCQEMJcd4/koEO9bvz5vc3BMRzKLpmYA9asFWAA0Gn3RHztSinh8PhQ1+EwIKrc5Pb6saep2+gwDPfHdzYZHULazF7lxgxCFmLLxAC7MnDSGEyIsUKMiIiyizIn2C0IJLd2AHhXSrlNCHG/EOIqZbOXAAwVQlQB+COUu5yllO0AHkcgqbYJwAYp5ZxM/xsyae7WxojLrzyFY1nR/P17J2HNXRE7aerK7fXjuSV7w5Y9u3hvv+0yNQBi4nEWIiLS3kgpZYPyuBHASOVxInO3ksb+NX8X3ltfi/9+fR3GTZuDfa29RodEcSzdc7jF+t8/Db/fLto1Vaw2i/F8srk+5vrWHlfKx07XqfcvwI9fWNlv+YqqNgOiyW33fbINFz+xNFj4YBZOjy+jr8HNtZ1R15k90ZQtmBDLMlJKeP0SXU4P/Hnep1a9k1hNjNmsfDkTEVH2kVLOlVIeK6U8Rkr5gLLsr1LKj5XHTinlj6SUE6SUZ0opq0P2/Y+U8kQp5UlSytuN+jcY6d7vTjI6BNMbUVGM93/7rYyft9rgAa/t9V1o6TZuAIWIiIynVNUnPXiSD/OvZtqyPa0AgMq66IO9ZA7RbkLTy96Wnpjr7/6oMuZ6vW2JkKBweVnxGMnupm6MmzYH2+u7kt537b5AsW8qRSBVzd34z6r9Se+XiF++shaT//GFLscOlQuj/FXN3bjs/5aiy+SFPMwgZBmPL/DrISXQ7crvtol9S5ZZIUZERJS7PtrYd2q1gG+OH5rhSLLT5HFDsO1vlxodRj963uV4xVPLcOGjSwLn0e80RERkPk1qK0Tl/2rP3kTmbgWQO/OvEqXiUK876jo9rqniXQ/68rwgIJvMqwwkUz+rbIizpbYuf3KZbonTldWsBkzUkwursLOxG0t2m/tGEibEsozHd3guBrNnW/Xm6JMQY4UYERFR7rp91paIy08YVZHhSLJXmc1qdAgZl+83kBER5anQ+Vd/DmB2yPKfiYCzAHSGtFYkjXQ6PFi2x9yDoWQcM92k9Of3t+C7Ty9PaV8zz3uWjw4XkAT+L0z1Sss+Ukr86PmvsGBbZqtFM4UZhCwTmhDL93nEHB4fhpQVBZ+zQoyIiCh3ub3+iMsFG6nnBP4ciYgoFUKItwGsBHCcEKJWCHEjgIcAXCyE2APgIuU5AMwFUA2gCsCLAH5vQMg573f/WY8bXlpjdBhEEW080A53yNjq1gRbeGZjldqs9bVo6HQYHUZGqT8lfrRIj8vrx9qadtzy9kajQ9FF/t0mmuXUjDfACjGH24cJI8qDpdy2QuZ3iYiIiLJROhOxJ3R8XY9ORERGkVJeF2XVlAjbSgA36xsR7W6KPR8UZbdoiQaJwPxB44eV6x7DwUN2DCguxMDSwqT229/Wi2v+/VVK5/yvF1bi/d99O/jc7NeWPS4vbntvM44eVoZFfzo/I+e8+c0NmLOVRbep0vvzUCaZPR/JDEKWYYVYgM8v4fL6MWpgSXCZzcoKMSIionxy5xXHGx0CZRmzfzgjIiIiykZ2tw8XPb4UTy3ck/S+8fIAfVef+8hiTHl8SdLn6bCnPo66bn97eEwmT174lfhaul0ZOyeTYdlBmj6dqz8mxLJM2BxizuxMiNndXry95kBafzycyvxhRwwqDi4rZoUYERFR3th+/6W46bxjjA6D0rS2JjC4wJaJREREuYKDrflsw4H2+BtpoLXHnZHzEBkhdMz8no8qcexdnxkYTe5hBiELOD0+7G7qBhDeMjFbK8QW7WzGHR9sTauM3qEkxFghRkRElJ9Ki9j5OxU1D12J848bbnQY/dz78TYce7f+H/Q4REdERKSflXvbmKigmFK5FjNjNZYRES3f04rKBOc8o9zxxqr9YfPepUuwZwYTYtngjZX78d2nl8Pl9SXVMtHt9eP6Gaux6WCH3iEmxe0N/Bva7alfJDncgYTY0PIiWAsCv8isECMiIspNS3Y1Gx1Cztr810uMDiFIvUYkIiKi7OP3S1z34qqU9v3bJ9s0job0YsLcVN64/qXVmPr0cqPD0F2s15he3dIaOh14dcU+XY6dj8z+NsEMQhaobu2By+uHy+uHN4kKsaYuJ5ZXtWKjxuXKX1W1YtqsLSnv7/UH/g3pVLipLRNLiywYVFoEACguZIUYERFRLnp5RY3RIeSU4782AADw16mTkp6M3Ch1HQ5Nrml5PyQREZE+5m9rTHjbLqcn7EaYV3itlzVcad7A9HQKc4yZkZGJwcZOJ+6dXQmvhlVDZpBIB/VIN9At3d1y+EmKP5cbX12H+z7ZjvoOR2oH0IDZk0jx7G/rxSeb6wGYP3HOhFgKOtOYhDEVdR1OAIFf+tASyS6HN+Z+asJJ67ttl+5pxcy1B9HWk9rEjD4lIdaVRkJMbZlYUmjBYGUgx2bly5mIiCgXhX3IAXDuxGEGRZIbbrvkWLzyi2/gV+eMNzqUhJ390CJc8++vjA6DiIiIouhVOvkk4pT7FuC/X1+nYzRklHjzwkZ6nSQ6dr61thONnc4Uosot0z7YgtdW7seKvW1Gh5K29fvb8c+5O9I6xs9eXtNvWbI3walj6OqYtdlpmXDqSKODW6g7PtiqyXEygRmEJO1t6cFpf1+AbfWZ69mqZqfdXn9SLRO7nYGEWbp3b/Sl3oFQ1ZzaHGBaVIjZ3YcTYoOUhBgrxIiIiPLDGzd+0+gQslqhpQAXHD/C6DCIiIgoD72xcj8A4Ms+NzxR/oo3uK+u/+4zy3HuI4t0OL/Eg3N3YGdjl+bH1sOSXfr/7sxaX4tV1fon3H7w3FeYvrRa9/NEolf7RT1p3e1idXUbTrv/cyxIosI3EYlU+xmJCbEktXS7ICVQ256ZEkopZVhCTG2ZWFxYkEBCTJ8KMTWhVdWSYkJMSah1OWNXuMUSrBBTWiZaCgQKLXw5ExER5bolfzrf6BByzogKm9EhEBERUc4Kz3asqTlkUBxkVq1KB6rrZ6zGuGlzYm7r8SVeGrOltgMygVKaDrsHLyytxrXTE5sDb9qsLVi8s/8cx3tbeuHyRq6UlFJi3LQ5uOOD1KegyaTb3tuc8PcjG2040I5T7luAeZXaJoKyzebaDgDA2ijvyybPa6WMGYQkqaWTjiRKwdPR6fAEq6HcvsMVYsPKbXFbDh6uENM2VvV7kGqFmBYtE53uwwmxwaWFbJdIRESUoxo6w29CGjeszKBIctfcW8/FJ7ecY3QYRERERJTHlle1anasr6pacdUzK5Kai7jD7kmoJePMtQfxzrqD/Zav39+OOz+ojLiPOhb69pqDqE6xwCDXdBtYobXlYCARtHKvdq+5dJl93q1cwixCktTqqF536tVNyagLmcwvdA6xYeW2uKWd6huL5i0T/ca3TAydQ+zyk0bhJ2eOTflYREREZE5+v8S3HtS+LQqFG1Zuw8mjBxodBhEREWWxXK0koOx04JAdALC7sRtAoEXn1c+uiLvf81/uTeu8a2ritxlsiJJ08/tl1sxhpYWVKcyBlsvvMzKkmpbJMX0xIZYkv/LGZHdlpkKsvuPwm6Tbd7hl4rDyInQ6PDFLf9UKMc1bJiox7DWwQiw0IXbB8SNw99RJKR+LiIiIzGm+xr3MKbaRA9g6kYiIiIhS5/KkP16aSJvDaOZVNuJ/3t7Yb/kHG2oT2v/Vr2pSPncqJt41F/d9vA3MH8NgAAAgAElEQVQAcP6jS3DCX+dl9PypklIGp8TJBWaf8ypTOh2esK54WhfZmAUTYhG8sWo/Jt41Fx12d791anWTPUMtE+v7VIipLROHltng8clgYiiSLp0qxNSEVn2nE72u5Cvl1IRaWhViyve/uMiS8jGIiIjI3KZ9sDXs+clHsopJT2OHlBodQkr8fpnSHaZEREREpK3V+1KbIy70RrhZG+rC1kkkniD77X/W4+PN9Umd28hkiMcng0m4A4fsmhc16OWBOTsw4a7PEq5o21LbgZrWXp2j0tbyPa1YuKPJkHOvqtbvs02sSrRT/7YAFz3+pW7nNgsmxCIoEIE3pEiJJJ/SLtCeoZaJfRNiwZaJFUUAgC5H9Dj0qhDzhLzZVbck/2amtlzUIiFWUsiEGBERUa7qe61w/VlskaynZ396evBxzUNXGhhJ4rbUduCmN9bhuhdX4fPtMT6wsu0IERERkWn95o31wcfralJLqoVSL/16XF6MmzYHszcllyTLBkYWNb2+cj+Aw2O8ffWN7apnVuD8R5ckdOxkEqDp7htr6+tfWo0bX1uXcizp+MmM1Wkfw+vzo7kr+px4oT8jEZIVDp2+qS+3148/v7c58vGyqMqOCbEIiq2BJIszQvVVpivE+s4hplZXDS0LtLSJlVRSE2Iur7ax+vx+FFoCr/Kqlu6k91e/h/HmQIvF4fGh0CJQaOFLmIiIKF8MKi0yOoScNqKiGABQZLLrq0jX5KqrnlmBL3Y0AwjMQ3DrzI3BjgqRZNMHNSIiIrPa2dgV8+8tkVnUttt1P0c+zPdU3dKDB+fuSKudZV8d9sTGhR1JjMGr4cW75hdRNvjPqv058952z+xtOPOfC2Nuk+xPc+nuFry3PrH2o2Zmrk+7JmErDHxb1Aqx9fvbsacpkPhRS0F7M1ghNrQsMPjj8R1umTisIn5CTK+WiV6fxNghpbAUCFSlMI+Y+j1Mq0LM40Mxq8OIiIhy0jOL9mDctDn9ll90wkgDoskvb/76m1j0p+8YHQbaelwYN20OVlW34fh7Ds+lsH5/O+ZVNkTc5+UV+zB7Uz3W72+Petx8GLAgIiLSU01rLy77v2V46LOdwWUHD9lzdq4ZMl6mr99eXbEvsyeMYMOBdry79qDRYQT98tW1eGFpNWrbo1cPJSI0oXb7rC0RtxF96sv+FFKRFC2RFe8Y8fQoUwK9sLQaLy6rTmpfrWj9Ov98e//5uFu6XcFOcqGn0/qewQNt+iei02E1OgAz6lshdteHW3HM8HI8+9PTg8mcRLLTbq8fDZ0OHDW0LO62y/a0oLHTiR9NHhO2vL7DiXHDytDW64Y7NCGmJMkSqxBL/aLk0fm7cPpRg3Dh8YcHoLx+iZIiC8YNLU0pIaZWuTk9fri8PtisySe2nB4f2yUSERHlqDdW7Y+43FLA8h69nT1hmKHn9/slCgpEMKk1Y1n4gMQPnvsKQAotHfnSISIi0kRbrwsAsPFA4G+1zy9x7iOLo27/9hrzDOpTduib8/gqhbli00ku3PfJdvzi7PEJbx8ab7RETLLhfP/fgWveH39jDJweH6Y81n9ep0zmCROdKyyR41gtyV2Yb6vv1OTcsYRWq6VTwGF233jgi+BjKYHHF+yOuF26ybk5WyPfwGgWrBCLoG+FWI/LG2w76A1WiMVPiM3aUItLnliaUPLsP6v249nFVWHLPD4/mrqdGKck1FxePzxqy8TyQIVYVxoVYp12T8wWNEBgQOrDjeF9dr1+CWtBAcYOKU3pzgBfSH/ZWHOgxeJw+1BSxIQYERFRLiqIcOff5nsvMSASyrSj75yLJ7/YY3QYRERElKD9bcnPLU+kt2ASJQf6Zde09cac18mM2JQhOr9forJO/yRfPDVtvXDnSHvIZKWdEBNC/EgIsU0I4RdCTO6z7g4hRJUQYpcQ4tKQ5Zcpy6qEENNClo8XQqxWlr8jhDBkogi1FZ+aLHJ6/MFE2OEKsfiJnJZuF1xePxx9kk4r97ah1xW+v8PjD5Ysqho7nZASGD+sFECg4kytEBtaHvjWdMeYh0utEOt7XNWPXvgKTy2MPeDg9vrR2Bn+puvz+2EtEBhcWhQ3a769vqvfL7k35K6CVLPuDlaIERER5axIH1sHlhRmPI5899LPJ+Oln0+Ov6HGnvhiN5qUCaC/2NGkzUH5qZyIiEhT6p/Whk6noXEQRfLm6gMAEmsSkG67z40HOtLaP5ul20IxWVqnN41opz59WTWmPr0c6/cfSvkYMsKHmz/M3Iib39wQsiT2d0vq2TMxiqYupylagWpRIVYJ4PsAloYuFEJMAnAtgBMBXAbg30IIixDCAuBZAJcDmATgOmVbAHgYwBNSygkA2gHcqEF8SbNZlQoxj1/5vy+YCAtWiLniV32pibDQyfi6nB78dMYqvLA0vB+pw+3t9wasXlSMVSrE1ISYEEBZUaDbpTPGm3Z3sEIscqy17Q40dsW+cHH7/P0ubjw+CUuBwICSwrgJrQfmbsf9n2wPW6a2TAQOV7Ely+7mHGJERES5KtHe8KSvKSeMxJQTRmL2zWfj6GHxW4Br6Z7Z22Kuj9flIBr1pdUc5xqYiIiIogm/TuP8nGSUt1YfwPb6rpjbxOqspXozSrv2RM3UeYDfzL9jkVo5puvS/1uKv7y/Bd99enm/dV//++eanMPIj5vblNds32RiIj/nWHF/tKk+rVaFL3y5N+42sUJMZN62X76yFrfP2oLWHlcSkWkv7YSYlHKHlHJXhFVXA5gppXRJKfcBqAJwpvJVJaWsllK6AcwEcLUIjHxcCOB9Zf/XAHwv3fhSEawQUxJJDo8vmMTxKwkxewIVYs4ICbH2Xjf8EljVp/+tw+PrlxBTq8jU+cI8vkDLxEJLQTBpF20wwOPzw6kk9NQKscq6Tjy2YBeklPD7JexuX9TqMSBQDefzSzR1OYP/bnV5oaUAA0sK0e30xuwj22H3oLfP90qLCjGnx4dStkwkIiLKSdnWEiTXnTpmEBb96XyjwwjjSbG9R2t34MPX/G39J5kmIiKicPUdDoybNgezN9Vh6e4WvLGyxuiQKC8klq2488OtuOKpZTG3qW6N39JTo+mxYtrb0pPSflXN3VHXxfoumTmJloh31h3EVhO0FYxnR0MXahJ4jaUi1RsAVckm/R78bGda54tl9qY6eHz+YCJMqznpUqXnHGJHAghNkdcqy6ItHwqgQ0rp7bM840IrxLy+QLvEvhVi9gTmBTucEOufANp4sD1sbjFHhOSUmiArLw5Ug6kVYkWWAhQUCBRZCqKW9artEkOPM6+yEU8vqoLL64c9QrKuLzUej0+irdcdXO71ByrEBpUGWhfFutsiMP9a+DnC5xBjy0QiIiKKrfqfVxgdAplMW487/kYR3NencwERZa8elxezN9UZHQZRTtvVGBiM/3BjHX728pqIFdyRWncRpePtNQeMDkFz98bpfuCIMs7scCd3E9gHG2rD/zZqXAllhkTb7E11aOmOXGGU6fAuf3IZzn90iS7HPv6eebocN1mhr80VVa0pHePWmZvw9KIqrUJKW0IJMSHEF0KIyghfV+sdYJR4bhJCrBNCrGtpadH8+GqFmMvrD7Yk9CpJHDWZk0hCTH3BhCadOuweZZnEhgPtweVOjx9unz+sEkvdr7TIAiEC7Qs9Pj+slsC7mc1aEDVbrCaaKoqtwcSW2sKx1+UNVp/FqhALnVivIWQeMa8vMIeYOpdHrCqvHqe3X8tGr19igJLkSzkh5vahmBViREREeaGggC0UKVysD56RPqj3ax/CtpxEWe+uD7fi1pmbsKU2f+duIdJbrGSXGQbGiVRurx8r+3TjMkKql5j/+86mqOuS+V3747ubcevM6MdKlVaXzlq0xr915ib88tU1Mbd5Z91BLN2des6gwx775jspJWQOvQnGancYmjuYm0ZLxqcW7kFzlERmpiWUEJNSXiSlPCnC1+wYu9UBGBPyfLSyLNryNgCDhBDWPssjxTNdSjlZSjl5+PDhifwTkhLajlBNOPWvEPPGfeGrCajQF05HSAJoVXVb/21DklDqfkUWC4osBUqFWKBdIQDYCi1xK8SGl9uCCSn1HD0uL3rUhFgCFWJA+CSpPr+E1ZJYQqzb6Q3OxRa6/xClDWTqLRP9rBAjIiIiyqBXfvENo0PQTLSPfOv3H8K4aXNQ1ZxaWxsiyhz1M2oiN6sSUXpC/27ynhIyowfmbMd1L67S/TyhY7nJiPd7s/Fge+wNkvTTGdp+Lw4e0r+lfaSkTLTEVGNn/MTKz14OJM2e/3Ivxk2bE7FNX7SkvyNOu8Lxd8zFbe9ujhsDALR0uwxp18636uj0bJn4MYBrhRA2IcR4ABMBrAGwFsBEIcR4IUQRgGsBfCwD2aXFAH6o7P9zALESbroJqxBTfgHURJhPnUtMImoySqXO4RVaIaYmgI4cVBL2JqrOSRaaPFKTVUXWgmB7RLVlYiDO6BVi3c7AeYaWF8Hl9UNKGaxY63YmXyHWGJIQ8/olrAUFwZaJHVGSWi6vD26fv9/3yeuXKCmyoriwIOWEGFsmEhER5Ycnrz3N6BBIccHxI7DngcuNDkMT0QYlPt5UDwBYvkf7LhREREREpL0dDV14beV+TY/Z3OWMuNxMN03dM7sSlXWdEecZq6zrCjwwYRGTlBLb6hObH+xXr65N659QWdeJh5S5sULH57VIFn2wMbG2zdfPWI3fvLE+7TnB9JRvNzqknRATQlwjhKgF8C0Ac4QQ8wFASrkNwLsAtgOYB+BmKaVPmSPsFgDzAewA8K6yLQD8BcAfhRBVCMwp9lK68aVCTTgFKsTUVolKQiykKizenWiOSHOIKZntS0/8GjYd7IDD7YPfL4PnCW0vqCarCi0CRdaCiC0ToyXlutQKsQobpAwkodSEWFiFWKyEWJQKMa/PD0sCLRN7lBj6tUwMabnY5fBG2jUuu9uLErZMJCIiyinL9rRgXmV4G4YzjhpsUDQUidqpINvFagtCRNklhzoWkYaEEMcJITaFfHUJIf4ghLhPCFEXspwTlcYQ6/eLv3pkFpc/uUzzY/7+zQ2aHzMVUvkvkv1tdkx9ejkuenxphqNKb+7ADzfW4cqnlie0bXVrb8rnAYCpTx8+T1VzD7qcqRVmhGqKkiyN5sAhOwDAH+ENtbnbiRnLquGN0cFNL7GSYKn8fJenOL+YEdL+RCul/FBKOVpKaZNSjpRSXhqy7gEp5TFSyuOklJ+FLJ8rpTxWWfdAyPJqKeWZUsoJUsofSSkNaSxZUBBIQEWsEAspr1SrrKJxevrPIdbp8KCk0IKzJwyFxxfIiIcmtUIfe0IrxKwF8Hj98Ia0TCwutMAVp0JsWLkteNxgy0SnF70uX7/z9RWaEGsMnUNMaZk4QE2IRSlf7Q4mxPxh7SW9fglLgcCA4sKUKsTUBCIrxIiIiHLLDS+twW//E/7hc9TAEoOioWjOHDck+PieqZMMi8Mfoe2Jam9L7Lt3E7kLsrbdHvGO21CVdZ1YuKMp/sGISHNMa1MsUspdUsrTpJSnATgDgB3Ah8rqJ9R1Usq5xkVpTi6vD/fOrgxrVRY674/XF/73l0lpykVaJE5CZeJmrDlbUp/fSbWvtRc3vLRag2ii29UU+/o6Mcm/8Ux9ejl++NxXaZ11/f5D+OY/F/Zb/tHGuphFJ5G8vKIGZz6wEP+YswNvrz2YVlyRaFb1FXIcrd7ujf67kRu3eOrAZg20I1Srm/rOIQbE7yeqVmSFth7ssHswqLQQQ5VEVafDE3acSMkxNSHm9vnh9vkPzyFmLQhWlvWlJqOGlgXO4/b6wyrEetOYQ8zrk8EKL/XfEIlahSZleJWczy9RqMxBlsofGPX7wgoxIiKi3Gcp4JCn2fzPlInBxzeeM96wOI6+M/IY5r7WXkx57MuEjzP5H5+jvbf/DV7nPLw47h23U59ejhtfW5fwuYhIe+ncpU55YwqAvVJKbXuq5aiPNtbhtZX78fC8XcFBy9CrsV5lyo/Wbhfu+nBr2E3gRNko1thoupq7nXh43s6I1UFae399+kmVB+Zsx7I90St9WnqcaOtJvX7F6E92u5vSa3m5szFyMu8P72zC/32xO+a+Ugaqyz7ZHGjRvvlgR3CdPUrRTXWcm/zSYXRSykhWowMwK5vVolSIBd4Uvf7w1olAAhViSjIt9O6ZTocHA0sKUW4LJHN6XN4+CbEILRMLAnOIub1+eH1+FCotE4sLLf3aEaq6QuYQU4+rnqfb5Q2+AcW6cHH7AtsPKi1EY1efOcQsBbBZLSgptERNiKlJOfX8RdaC4P6WAoHSImvSZabA4UQkK8SIiIiIMu+cicOMDiGmRK4vQz+Mt/a4saq6DZefPEq/oIhIc/k23wWl5VoAb4c8v0UI8TMA6wDcJqVsNyYsc1KHvaQ8nG4O/X1TH9Z1OPDm6gNMiFHWm760OqHtXvuqJu7Nen3XTpu1FYt2NqcYWYCZEhc/eG4lAATHpvUmJXAowo1r0b4niX6vtjcEElu17Y44WyauuTs8UfjW6gM4ZfTA4PPXV+7Hw/N2JnXMC5O4ya+vZKoSY225bE8Lpp5yBID+eQQpJZ77ci++d9qRScVm9M1MrBCLoriwAC6PL9j20Ofr3zKx7xxiPr/ENf9egcW7Am90DnfgRRL6YulQEmJltkAustflg8MdmjgKb5lYaBEoKBAoVBJinpCWifEqxEqLLChVqqjcfVom2t3x5xBTYzlqSCkaOp3Btoc+f2AOMAAYWFKIDnvsCrG+/y6fX8JaUICBJam1TGRCjIiIKD9svOdio0OgLPTkwj1xt4k0kO7zS80nZCciImMJIYoAXAXgPWXRcwCOAXAagAYAj0XZ7yYh/j97Zx4nNX3//9cnyczsyV7c56LIISggCB6IooJY7Revth5V22q1v2ove0hbb/1WautRrVqp1mq1Vr/1QlEU5BBBkFvu+z53gb13jiSf3x/JJ5PMJDOzuzM7u8v76cMHmeST5J1hmZ3k9Xm93mw5Y2x5RUVFq9TaFuEuT5djH063pYf1BJFOdh919q+6f8Z6x+T/VPAyMsSiJYgCT4XqxgiW7Wo72r6XwLJgq/vnqarpOOoifAFo8nueCm8u2wMAmL85vp4XFuxocvyhG797d62jh9miJD223D5vW4tEk4w221xxsRrArqMNeGzWZpwzbW6mSssIJIh5ELB6iAmHWHJBrD6sYtWeKqzeY1geXXuINcQKYqolnAFAyCZwhVUdflP8ckYmJneI1QYjKMxRLFdWyBGZGEGd2UMs0T9wsa1vWT7Cqo7j5g+9qnFrRkRxnreoVWuLQ7QLYsIh1lxBbM4Go09DYQ4ZHAmCIAiiI1OS7892CYQHc+4aj79cOyLbZTQbtxmTNMOdIAiiQ3IpgJWc88MAwDk/zDnXOOc6gL8DGOO2E+d8Oud8NOd8dJcuXVqx3LZK9PfmXW+tyWIdxIlKSwWjpsLA8MzcbXHrU3W2RDS9SaJKZZ27GJSqRnLrK8scxgQv6kMq5mw4jNpgxDUyfM7G5rnZ1u2vTmncpoPukYP3vLcOlS2IYhSky3n0nzT29ErF0d7UqtOhnaXqtE80rLX/XaYLUhQ8yPHJCNocYqrVQyz6YdYQdn7QiA86EaUonEz2D8DqRqOHWL7feOtjIxPtubVhTYdPsQliZmSiENPcHGIr9xzHsbowaoMqCnN8CCiGiyoUiTrE6kMaZEmPqy2WsM0hBgAHqhpRmu+Hqkddap0SiFoOh5jtGlXNcJgFfJJDKEuFp+ZswVNztuK8UzpjwuCuTdqXIAiCIAiCSA8DuhZiQNfCbJfRfFzu7NI9KVPTOUKqhjw/3XIRBEFkketgi0tkjPXgnB80X14JYF1WqmrDiOdgC7dW0nMXos3wwIz12S4BAPDYrM1Jx1Q3RDD8oU8BAOcOKPMcl87JWOsP1KQ07jdvf42ZXx+0Xu+adllazm93QgHA03O3YdLQ7hjWq8hjDycz1x5MPsjG0fowOOdgzchPrmpwFx/teAk9qcQQXv7MQhQGfE2uKxWacr2tES29YvexzJ8kA5BDzAPLIWb1AYvvIRbrEBMfZPVhFRFNt8ZGbD3EqhrDKM7zQ5YYcn2y4RCz9xCzLUe0qEMsYDrE7JGJbg6xZz7biv/3+gpsPFiDTjkKAqagFtY0yyFWG1Qt0S5R40ixra8piB2qDlrvgWyLTEyth5gzMlGWGHySZL2vqRDRdDwzdxsuGdoN//jemcihyESCIAiCIAiiGTTl/vA7Lxi9EnZW1ieNOrFz7/vrcOp9n7TbmZNE+th2pM6K5iEIovVgjOUDmAjgHdvqxxhjaxljXwOYAOAXWSmujRJSNfznK8MZsb8q2ltnzsbDnvvQbzmiNXhv1f5sl5Aylz2z0FpONOHKyy0VSzqFs9gYyExy/d+XuK5/YUFqPduSUdOoYtmupgsyU55dlJbzxyLuL9btr8GXO47Gbf8iwX1Ettuibjlc53i9q7Ihpf3ufnttJsrJOCSIeRB1iDmFME3nyDf7ctXHWFEjqjGmLqQ5RC7xwSWOV5RrqMT5AQX1YdUSqgCncBRSdSvy0G/1EHNGJsY6xI43RBDROHYdbUBhjs/aP2hziBmRiapZG4fucZMuHGK9SnIBwLKuRmw9xIqbIYgJh5kiM+gcnueP5VB1EJrOceHgrpYoSBAEQRBEx2DtvtRiNoi2x01n9wMAfGd0nyxX0jK8IlaW7jRutCf8eT5ueHFpysd704xayWY/ACJzjH9sHq6d/mVKYyc/9XmLHhjsqKhr1gOfEwb6J0Z4wDmv55yXcc6rbetu5Jyfxjk/nXP+Pza3GAHg4Q83YPPh6EP6VH6F2Z9/EURHYfPh2mZF+DHGsO94Y/KBAJbujBdN3Hjpi51Jx7T7r5se9Sf6Hq1zjm/9LbXvYnZ2H21wOK1mb4gX/N9a3vTIxC1H6lyPlQocwAHTiNJU7n1vHb7/8ldx65sissXW/Y2nbaJus6pKTLZ/XklV8CDaQyw2MpGjMMcQtBpjHGLCUVUfUhEMxwtiNaZwJASxgoBsimfuwpG9h5jPJogpNtdYMOaLR01jBLmmc6rQ5hCrsYlWdSHVIeZ5ucSEIFZgRjRGNB26zsE5oEiSdS2xDfWi57H1ELPVKRxiQlRTUxTExC+U3iV5KY0nCIIgCKL98M2/OmM2PrhzXJYqIZrKQ1OGYde0y/DHa07Pdikps2CLe0NvL+Y04+aWhLCOzZ5jDViyIzWRKtX7HS8ufHxBsx74pJNrp3+Jd1fty2oNsaQSW0QQRNPYfCjWsZL888sev0YQHYn5m5v2fREwEgXs7KjwdmQtcXERuZFKb7ATkZZ8u7J/g/jhq8vjtns9604klK3ZW+V6rEzwyuJd1r3Gv5bsxryYn1Vd580W2E4ESBDzQMQRCiHH7hAL+CT4ZQn1sYKYKSDVBd37glXHCGL5AcWITAzbXWG2/ewOMVtkohWj6JMRUnXHzXZVYwRTRvTE+IFdcGZ5qbV/lV0QC6qoD8ULdrGI9aJnWVjj1s2cIkcjExsjmmsvsjpPh5jhMBPCnr0vWyL2HTfsmr1NxxpBEARBdAQYY5MZY5sZY9sYY1NdtgcYY2+a25cyxspjtvdljNUxxn7VWjWnG7dIudN6p5Y3T7QtTkuxT0A22V5Rhw9dHt4l0q9ubcHNbXN6GxBEW2PJjmP4xZtrsl0GQRCtDM3tIIiWcajGW5SYs/FI0v13VNYlHZMN7O2BvKgJpi7ktbbTtLkfbav3VjX9XBn4HD1QHUzYNy6SwrP2VCcWdcQ7GRLEPDDcVzqCppCj6hycG4KQLDHkBWQ0hGMiE00BqS6kOqIMVfNDQohSxXlRQawupoeYXViKaE5BLBITmSjcX0Js4pyjujGC0nw/Xv3BGNx8TjkCiuEWs8ca1oZUx+wCNzHLfly7Q0yIV6KHmLgWt9jE2qAKc5hTENOcDrFUPkQBwyHGGNCjiAQxgiAIomPAGJMBPAvgUgCnAriOMXZqzLBbABznnA8A8CSAP8ZsfwLAx5muNZOc/LuPsl0CkSby/G2vx+usdU7xq87l5lznwGOzNqX1vPQMkSBaB/q3RhAE0fE5UT/r526qSElQ8Yr+Bowks5qgu+Ppo7Vtw+HZUje9INW2PK1JpsS+lvaW+8ei5FGcAIAOOLmPBDEPhEPMHkmoc0DTOBSJId+voCHGISZ+EOvDqmsPsWrTblmc6wdgCE31IdVxDkdkoqZbvbLsDjHhrMoxoxHFPnUhFZrOLZEKiIpmxxvCAIB8v4y6oOoQ8zwjEy2HmHEeVdOjDjFTzOqUKwSxcNz+tSEVpfl+s8boNao6hyJHBbFUG43vO96IboU5lkhIEARBEB2AMQC2cc53cM7DAP4DYErMmCkAXjGX/wvgImZaThhjVwDYCWB9K9XbKnz52wuzXQLRgfjRayuTjnl89ma88uVu63U6bqXFw4v2dgs5a91BVDXEf7cniLZGB3w+QxBtjkdmbsx2CQRBtJDRj8zB6Q98CiDeFfTj15N/T04nTf3d3dTv5E/N2ZpaHU08LgAs3lbZjL0IN7ItW5Ky4IHlEIvYhRwdGueQJQm5/niHmHBaGTGI8ZGJVZ6RiVrUSRVx7yHml42eZhEtus5yiJk1VsUIbvYxQozrUhhAXUhFXUiztnk5xMT6PH80MlHTnIJYUa63Q6wuqKIsPxB3XVYPMRGZmKKive94A8UlEgRBEB2NXgDsQeT7zHWuYzjnKoBqAGWMsQIAdwN4sBXqzAjH68M4Vh//4J3c4O2X9vCA+ut98VEnsf0dTtSIqEPVQfzotZWt/nDkRGLpjqPWfeSWw7U4WN2Y5Yo6FlOeXYSJTyzIdhkE0WHYX0WfUUTb4ETqo/XnTzZby5wn8n5FSfTdNRWH0r7jDaioDaVwpqZRWZf+YwrcbjuOutxbpouKDF5LW2b/8Y73e/I57ucAACAASURBVIAEMQ+iDjGnkGOIOYbTKtYhFnZEJtocYqoZmWjOtCwyHVwFARl1IQ0NYQ35fgWKxJw9xDTu7CEWE5kY6xATopRwbQGIi0zsWpiDhrCG2mDEcm8lEsQUiUGWGPyyhIimWxmkQswqzvM7jm+nLqSirMDYHrQ7xDQdiiRZ1xFJ0SG2v6qRBDGCIAiCiPIAgCc550mD5RljtzHGljPGlldUNL05dKYY+fBsnPHw7GyXQaSR8rL8bJeQlHvfT26obO0+Bm0FcS+yrwPe+LYFDlY34jvTl+DX//c1AGDSk5/j7EfnZrkqg8M1QeysrE8+sAW8tmQ31u2vTvtxn/5sK1btOQ7AaGi/9Ujb7LdCEG2RVxbvwmVPL7Rep9pThiCIzPHXedscr3kKM7VCHs92U2XcH+fhzP+d06JjuHHt9CUt2r+2CX3ImkJbm8RX4/Jc3Y1Uv0el0EIsZYId8L6IBDEPhEOsMeKM+jN6iJkOsVBsZKLxARWM6I6ZCyIysaYxAsaAQrMnV55fQYMZr5jjlxFQJGdkomrrISaLyETdEqOEw0v8YFbH9CgDYO1fZXOIAcYHZUme31p2w35+RWaIqLoVbxjrEBPHt1MbjKCswN0hpkgMipS6Q0zVdBysDqJ3SV7SsQRBEATRjtgPoI/tdW9znesYxpgCoAjAUQBjATzGGNsF4OcAfscYu9PtJJzz6Zzz0Zzz0V26dEnvFaSZk7u0fUGF8OaB/xlqLe+adlkWK2kZbe0mubVJbS4y0VTqzXvETYe8m6Bni7F/+AwT/jw/o+e45711uPyZL9J+3KU7j+HK5xan/bgEcSJw/4z1WH+g7X0mEURHpikTUPQ0xhaEVA1rXQSV8qkz03aOWLZXtM1JKqyNfdl/bv72lMa5GVJiWbe/GkPum9XSkjJKKiJvJiFBzIOA6b6qtTUd1DQOTdejPcQiTpXa3szObgmN2CITi3J9kEwxKT9g9CFrCKvI9ckI+GSHWyusatHIREUC54bo5ovpISZcbAkFsUanIAYg6hBL0ENM7O8zHWKqKfrJSSITOeeoC6noXBAvuqk6hywzKKZDLJXGiYdqgtB0Tg4xgiAIoqOxDMApjLH+jDE/gGsBzIgZMwPAzebyNQDmcoPzOOflnPNyAE8B+APn/K+tVXimGN67ONslEC0gxydj4W8mYMlvLwIAbH5kcpYrIpqCcAacqJGRmcb+vsY2fX/ms61Ysft4K1eUfuZtOoLjGYwrIgiCIIj2zj3vrUt57EdrD7XoXLU2w0ZdhtxWTaFtyVAdk2W7jqX1eDPXHsT7q2Pn7LZvSBDzwOq91Rj9sFCtyETm6hCzi1lCEBPOLuNYEUtAAozIRAA4WhdGrk82+4Q5e4/ZIxMFfisy0ewhpjp7iNnPIUsMisRQbcY12gWxElMQiyRyiMlRQSyscUu8EqJcpxzFujY7Rr8zjrJ8IYg5nXZOh1jyO24R29KLBDGCIAiiA2H2BLsTwCcANgJ4i3O+njH2EGPsf8xhL8HoGbYNwF0Apman2tbh3AGds10C0UL6lOahe1EOgGh8d3tj86HatB2rjU1ATUh7qrU9wxjDu6ucDxYen70FVz/fvl1O1Y0RfP+fy3Drq8uzXQpBEARBEDEcrmleD6xHP96YcHs6vzc3BS+DB+HO4Zpgs/f92X9Wp7GS7KNku4C2inBfCSEJiPYQUyTJcIh59BADDJELAApzFCtKsaohgmKbWJVvRidW1oWQ45cRVDWHkyqi8qhDTI4KYtHIRKdDrKrROGdxrt9RV0CRLMGqS4FNEDOdZJ4OMUdkI0NE06GZIaTCIabIEgoDSlxkosh47ZTrM4U+Yz/OhagoWQ6xSAofYKKBH0UmEgRBEB0NzvlHAD6KWXefbTkI4FtJjvFARorLAled0SvbJRBpZvqNo3Dbv1Zku4wm8f7qA9kuIauQQywz2N9Wr8ib9QeqUdOo4uyTy1qlpq2Ha63Jji1FTBDdfTSzvcgEJOASBEEQROp8w9YvsCm8sGBHwu2XPPW557ZMfqe8+IkFmTu4C20hZrElEbdj//BZi84dm27QniGHmAdRh1j0RkXVdcPdJBsOsfpw8sjETrk+q0dWdWMERXlRsarAJojl+cweYrZeW2FNh08x/rH5bA6xaGSi0yFW3RiBX5Gs9QK/IqHeFO/sDrFis5awh0MspNkcYooZmRjTQwwAAj4pTlQTPdQKcxTHddl7kPmaEJkoHGI9i3OSjiUIgiAIov3SFm40iPQyaWj3bJfQKjz+6WaMfiT1ZuQ3vrQUt75CTpoTkUSfcpc9/QWu+3vLGtA3hYlPfo4L0tQ7LNoPIj2f45xzjHp4Nt5attex/vn523HjS0tTOkYwouHpz7Z63vMSBBEDfQ0jiFahKX27atpA1GG6SOetXm0L3he1Ge6yn76xqtnnSwd/+Mjp1LvyucVYs7cqblymREitA82YI0HMA9FDrN7mAtNskYn5ARkNYc3RBM7+JbuiLgyJAXl+2RLKahojVsQgAOT7jeWj9WHk+mUEFNkZmajq8MtGHQE5PjIx1iFW3WBEMsY+SLJH1Th6iAmHWKLIRI8eYorsFOhiYxdFLm1BwIeALxoFaQlqMoNsRiYK11ki9h1vQLdOgXYbu0MQBEEQBEF0bJ6Zu83RRzgZC7dWYs7GwxmsiMg2R2qD2F/VaL3uQM8RXBGXJyV52PXiwh34fEtF0uOFNR1H68P4/XtrHev/OGsTFm6tTKmmvy3Yjidmb8HrS3enNN6NFbuPNenfNkEQBEGkEzfRg2gZ7dHsNP3zeKfelGcXZaGS9g8JYh7k2BxZuaY4plqRiQx5fgWazh3OKIdDrDaEXJ9s9d4CgMaIhjx/VNARkYmcG+cIKE6nlVcPMcXDIRYbySgImOMUiVl9w4BoD7FUIhN9soSwyl0dYorM4lxetSHDWVcQUEyhz8UhJonIxOSfQvurGtGzmPqHEQRBEERHIKzqeOmLnXHrF029MAvVEK3Bhz8Zl+0S0spby/bigj/Ny3YZaacls3bPe2wuXliwPX3FtCPKp87E459udqzjnGPM/36Gc6fNja4zJaNU3uf6UOJZzzsr67Fyz/GmF2vWtrPSO9bwgRnrcddbTe8VofPUru+RmRtx0z++Snq8fy/dYxzPw7LitV6weFslDlYZ/TJeWLADFzbTCXf181/iCnrgRBAEQRDNwp6IkOx3N3FikO1JYiSIeSAcYkBUuFK1qENMCFsNoaijyy7sVNaFkOOT4be5p4IRzepNBkQjEwGjZ5nfFi3IOTcdYsYHhd8lMjHOIdYYQXFevCAmYg9zfTIK/NFzlpqCWCiRQ0yO9hBTdd2ylMo2QcwnSXF9wIRt1YpMNM8hhDOjh5hxbDUFQay6MYLSPH/ScQRBEARBtH3+vnAHHv5wQ9z6XjT5pcMyrFeRtfy3747KYiUt53h9GL95+2vsOtpgrQtGtAR7tD/sriY7wYiG8qkz8e6qfThcE8TLi6LC9t5jjXj0402tVWKbQSSGPDN3m2P9h18f9NwnlYdBU99ZC13n+L/le123T/jzfFz13OKU63x96W68vWIfAOCNr/Ziwp/nY9muY65j/7l4F95ZuT/lYwvEww2pBcqqPTHlwQ/M3xPNOFwwouH6F5fiTfP9O1QTxA4PEXDxtkrHed0QEf4E0ZF5as4WfLXT/XOBIAiiuVAiQuuSKa3p633VGTpy60OCmAd2h1ihGXMoeojJErPiDhtsN792YSmk6sjxyfApzBKLGmMEsfxAdDnXLzmEIyGuWQ4xR0ShcUcQ5xBrNCITYxEOsRy/7DhnSZIeYhHNJTLRFnkYrSdeEKuzCWKG0GdGJprjFIlZx4ikEJlYF1JRYIubJAiCIAii/WLv0UqcONwx4WR8Z3QfTB7WvnuKufW/tR7ctyMe/XgjJsc0QT9cE0y4z5EaIzbuidlbcNury/HgBxuw91hDwn2ayqV/WYhn521LPrAVCEa0pGLn3zwazbuJik2ZDXugqhH/XbEPv/7v16nvlIDfv7sOv/y/NahuiODLHUcBIOUH36kKvpZDrHkl4svtRzHonllYYtYn8DpeRa0zxvB4fdha9hISY1m3vxrXv7gUf5i5MflggujgPDVna7ZLIAiCIFrI60uaHxOdiBtebL0et5mGBDEPAi7CVbSHmIRcyyEWjbKIaLojHiLXL1tiEeccwYjuENrsDrE8v+LoISZiDC1BKgWHWE1jBEW58S4qIabl+WUosmRFQIrIxFgxS2CPbFRkhojKbZGH9ghHFufyqguJHmIKAr74yERZYlbsopaCQ6wuqDreL4IgCIIg2i96ewxtJ1rMry8ZjD9ec7pj3d9vGp2lapqPm/nlja/2NPt4d725Grf8c1mz9//w6wMonzoT+443TZh6YcEObDpUi5k2J9PVz3+Z0r6cA8cbDGFbT3PmycaDNfjTJ5uTD0wjj3y4AUPvmxW3fviDn+L0Bz5NuO8fZ0VdcQ1hFTe8uMQzjvC+99dZy8neNc45jjeEXdfP3eQ+07ohrOKdlfvAOUdNMILyqTPxry93OcYMf+hTfLDmAAC4vs9uTqnvvrg0SbWiNuPPYw1h3P/+Olz53CLX99WLL7cbfcHiBDEPRWzz4VrH65EPz7aW731/fUrnFO/xtoq6VMskCIIgiBOGR1xSPYi2jZcjvqUI/aEjQIKYB8J9BUSFK1XnUHUdisQskawhbItMVHXk+WTLwWXvISYEIbcoRuN8MgI+m0PM/NMnuznEhCBm/Clm7FU1hF0jE4VwJoSwghwFjMFyk3k5xOyRicZ16JZ45ohMlCVEzAdbmw/VYsKf51t57wVWZKJmvYeA6RAzRTU1BYdYLTnECIIgCKJdwznHvM1HwDlvl02Micww8dRurt9f2zLp7nzwzqr9+GzTkZTGlk+dicdmOWMJ7/z3KgCpu31ieeCD1IQDICpMcG53A7X/XhAvfrET9eF4ISik6p79lt34fEslFm07igdmuL+ny3YZPb+qGsOusbGp8PbK/fjBP5e7bntwxgbc9dYaLNt1HIerDbffve+vR2VdyHW8G7fYjr14WyWenbcNy3d79yprCKs4UhNEY1izJj8GIzpe+XI3Vu2pQn1YS9kVLH41xP5M2V+/luZZzyLe0a7rNoY1z3tkguiobDtSm3wQQRAnHC+69H0miPYOCWIeCBEJiApims6h64YYlOsz1tWHnQ4xnyJZQleu6CGm6VZvMHtkYp5ftm4qc30yAopkffGOdYg5e4gZO0kSM+IIVUOoqg9rrpGJYl9x7sKAgny/YglqCQUxW2RjRNOtmxyfIzKRWQLepkM12FlZj61HalGa70dAkR1RkJbDTJasY0SSOMRCqnFDUkgOMYIgCIJot7y5bC++//Iy/HfFPldHyXM3nJGFqohsYXf+r7hnYhYraTqVdfGunUSwFvRTcuO5+dtd16saB+ccWw437aFmcw1eYr+WXt6SHUdRPnVmXPydnSM1QYz53znY3gZcPMGIhvP/NC/hmAVbKhJuP1yTXKBauafKdSbuoWrvXlaHzMjL+pDqcKD9pgmxi19sq7SWr39xaVK33lXPLcaYP3yGIffNspxnsQx/0N1lVz51pqt4GPszZX99z3vrkC42H6q1xDrx8/z+6v0Yct+spH/HBNHRuPiJz5MPIgiCaCGPfkwRxUT2IUHMA7tDTAhcqhbvEGu0zSQMazp8smT1Fwv4DNFH1XQETYdUrk0QYyzaiyzXJ1niFhAVqfwxbjAg6hAT64OR6Kw7d4dYNDIRMFxb+QHZiiz0mvUYUr17iNkdYookWS4vIW69f8c4fPiTceb5ZUsQdDjE5NQcYvUh472jyESCIAiCaL/sO248xD1YHQR3eQJ/aTvvK0U0jY9/dh7+9t1R2S6jWVzyVOKHhlc8uwivLN6V0Ro2H3IXvV76YicmPfk5Vu7xdvTE462IBSPeThnx77ilgthL5szjFQlcSDPXHsSR2hBezfD7amfhVqeotWZvFcqnzsTnWyqw+6h7PGVjRHVdn4wNB2pc1z85Z4vj9bzNR/DaEu94TvF30RjRHELn3BQdiKmws7Ie5VNnYs4GI7Zxk+1n8fHZW7x2Q33I/b35p+3v1EucTaekHFI1lE+dibdX7MMlT32OH7++0ji3+e/gH4uMeg6aDrs6l7rX7a9uE+IsQTSXmV8fdDzLIgiCaC0oKYRoC7RIEGOMfYsxtp4xpjPGRtvWT2SMrWCMrTX/vNC2bT5jbDNjbLX5f1dzfYAx9iZjbBtjbCljrLwltbUUu0Ms3+YQ03QOSWKWuGSP1girHH5ZQmFO1CFmCEncijW0C21AVKTK9cumcOTeQ8zvIYjlmP25qswMfzeHmIhpFGJcvl9BfkABY4bDzNMhpumWmOZTjOsQvcLsNfgUIxYSAFSz7s6FfvQszjXPH41M1PRo5KIQ5GL7j8VSFzT7keW0rzgdgiAIgiCiiIeNDO43Qul20RBtmz6leZhsiqAd7W9+9d4q3O8RmZeM15fuxl1vrbZeq5qOJ2ZvQU3QGTl3tN7dYbRmXzUAYO+xqGAzY80B3PPeWs9z6twQe+z7CAbfOwvjH4s6ZaKRidyS0aQ0/dtNdJioG61p59peUYewquNYfRhPzN6StH+h/X3+yRurHNvufttwWf35U2/H1MrdVXE1p8I3nl6Y0rjvv7zMcoFFz8Ot+znx7vz49ZXW/We6WWz2+Zqx5gBW7E49pnPax5s8t8X2LWNwRoAyxrC/qhEfrT2IlrLIdMD98v/WONaLvy9bEAo455j4xALr9ZbDtQipGi5/5gtc9PgCbDpU49mPmyDaKqv2HMcd/16J+2ekz21JEARBEO2Jllpu1gG4CsALMesrAXyTc36AMTYMwCcAetm238A5jw0+vwXAcc75AMbYtQD+COA7Layv2bj3EDMcUorEkGc6uxpCzshEvz0y0S9DMXtvNVqCWFRoE8c+UhtCrl9xRAvGOsQcApTtW3pAkRCKaKhuNKJbXCMTzX1zTPHtjH7FViRJQI6eMxZnDzGGsKpbbi5HDzGJWUKYuCGIdbFZvdE0u0PMFMSS3JjWhowbU3KIEQRBEET7xR6vdqyhaZFzRMemo2uh1Q0RFKXYJ+337xoPKJ/49ggAwCfrD+Ppz7bicHUQf7zmdGucV98usdYuxvzUFHYeueI0132O1Ycx5dlFcetF1LldgLELUiL6VGLMGpsqGw7UoFdJLhZurcBs02m04UANbv/XCtfxdjfOjoo69O+cn1Qce23Jbtzz3jpcdUYv1IdUfLL+MM4sL8F5p3Tx3OeuN9dg+o2jcP+M9daEQ4FwQm057O0M+lea+1ulwiMzN+KlL3Zi40OTHe/JL95cnWCv5iN+RnXOcfXzX6a8X6L3ZtA9s/Dxz87DX+dtA2BMzLSPrwupOHfa3GZW7MSr/5oV7S9F72P/sWiX5RQDgElPfo7zTulsvZ78lCFkrrp3Ikry/WmpjyAyTa054dj+s00QBEEQrUlzI9vTRYscYpzzjZzzuClynPNVnHMRIL4eQC5jLJDkcFMAvGIu/xfARSyLU4UdDjG/0yEmS9GowwaHQ0yHT2YxPcQYIppu5b/HOsTsYwOKDNU8hyWIpegQi0Ymxn8RD5jnzDPFuF9fMhiPXTPcOq7XrDbjetx7iCn2yESZWS6vsIuDLKDIcT3EDIeYGZmYZFadcIgJ5x1BEARBEO2b2OisNfdNylIlRFshxyfhjL7FjnX275vtmZ+/uSr5IA/E9/RgrIPG461JdPe0q7IegNHfauNB94g+O/NsMXtiXwFH1OnJGPDl9qNJj2fnG08vxPV/X+LoTzU/Qd+t15caMYGvLdmNCx9fgHdX7U96DtFr6sM1B617ttib7/KpM/GkLeZvf1UjPtt0JCvCVnMRkZPj/zTPum8CgB0xf2fp5sOvW+7WsnPpX6IuuWfmbvPsR5YplpuRnTY9DA9/uCFu3MKtlXHrRj48O2N1EUS6obQygiAIIttEkrRPyjSt0UPsagArOef2XI+XzbjEe22iVy8AewGAc64CqAZQ5nZAxthtjLHljLHlFRWJGxY3F1lilhNL9AsTYpUiMeSabquGsNMh5pMlFJjjc0RkoqpHIxMVp0NMHDvXJ1vCVVjVrchEuyAlcOshJmYwFidwiImaHduSRCbG9RATDq+YeiJxDrF4Fxtg6yEmR9/fSLLIRPOhGTnECIIgCKL9Yn9QH/vMPlX3DNExYYxh08OX4p0fn+tYr2V76mCaOFLrHm+YDE3n2OkhaqzYfdy1F59ge0UdHpu1yTHmgj/PBwDc/I+vHOKDF7e+GnXSiH2FmH2wOmglTjAWjURtCusP1Dh6caUif4p7iXX7kwt6Aklyutli+ctnW61lzjm2HI7vz/ZAMyMwW5OK2hC+2pV6hCERT/nUmViyg95D4sTATdwlCIIgiNZg8bbs/g5KKogxxuYwxta5/D8lhX2Hwog+vN22+gbO+WkAzjP/v7GpRXPOp3POR3POR3fp4h150VKES6zA1kNMNXuI+RUJPpk5HWIiMtF0j+X4ZKv3lhDEAi6RiQCQ65cs4SqkaogkdIhFb+RyfDKCqmY5xNx7iJmCmM9DEHNxaAk3nF0QUzUeFbTskYmyZCm7om6HaOeTbA4x3dxfsmIXk0WsWIIYOcQIgiAIot3SQbQNopWYdtVpGNK9U7bLSCvVDRHre699Up0XT83ZYok1768+gIPVjda2P32yGS8v2uUQvNYdqLaWn5m7Dc/N347DNc0T47yY9OTnceuY+Z9g8fZKfNGMB62xWtW6/dUonzoT247EC1Rr91fFrfNCZgxiEmoqpkO39Ix/Lt6V8vkEK/ccb/I+BEEQBEEQBNHhyXJmflKFgXN+cXMOzBjrDeBdADdxzrfbjrff/LOWMfZvAGMAvApgP4A+APYxxhQARQCalr2RZnJ8EupC0VhDu0MMMAQmuyAmHGL2GESNc4S1qEMsVpQSY3NsDrGQqiOkOQWxgEdkouG+0lFZF4IsMXRyE8QSOcRkd4dYbGSjT2YIa7olaDl6iNkiE8UNpF0wE5GJnPOow0xi1nUks0mKjOtCcogRBEEQRLsni4nYRDvg/11wMhrDGq4d0xcLtlRgw8EanHVSabt2baw/UIPqxgiGP/QpAGDcgM74amfy61kaM2b65zscrx/6cAO+sM2ufPXL+Ji/UEzUYkvYfChemAKM+1n7P+vr/74UALBr2mWu42MjUwWr9jhFrg++NiLzZm84Ejd22a7UxSaJMcttaP/8WeQyM3XToVqrV1hLEb3RCIIg2hL2iRR7jzUkGEkQBEEQHZOMKAyMsWIAMwFM5Zwvsq1XABRzzisZYz4AlwOYY26eAeBmAF8CuAbAXJ4oB6QViHWIqWYPLdkMFs8PKI7ZnWFVR55fsXpd5fqjYlNdyIxM9OghludXrPOFInpUkJKjDi1BbA+xmmAEe481omdxjkOosq7DF41ljMWXTBCTnZGJIt7QZwtXV2yRiWGNwy9LjptNIeaFbT3IjB5ixhg11chEcogRBEEQRIfA/j3hujF9s1gJ0da4e/Jga/nhK4ahZ3Euvj26Dy55Kt6Z1J4YYYphABwilp2aYMRafvCD+Ig+5hIqOHdTvFhk5/w/zU+xwuR4/R1IzK0ywyF1Rt8Sx7q5mw5j5e7U3F1CIEul39msdYfQpTCAUf1K4rbJMrMeAItbpWkfb8LfFmyPG0sQRMeCMbYLQC0ADYDKOR/NGCsF8CaAcgC7AHybc37CWDrtvzfOe2xeFishCIIgiOzQoh5ijLErGWP7AJwNYCZj7BNz050ABgC4z+wVtpox1hVAAMAnjLGvAayG4Qr7u7nPSwDKGGPbANwFYGpLaksHQsgRolWs+ynXL6Pe4RDj8MnM4foS4lWteYOb4xWZ6JOt84VUzTqXcGjJErPELmdkouEQ23u8AX1L8xJeh2cPMZdYkJCmOfb1yRJ0DmusbKvBJzFLKDNccs5b4uh16YjYeojJliCW2CFWF1QhMXdBjyAIgiCI9oe9R8/dkwdlsRKiLdO5IIB7Lz8Vg7oXerqN2gupTPM7/YGoaPbyol0p9dRqCzAAC11EvqueW+x4/Ys3V+MH/1yOv87bltJxhYtuxpoDrtvfWrYXWw/XYurbX+NHr63A1c8vxo6KOhyvD2OyTbyTGYNIaN9yuBbVDRESwwjixGIC53wE53y0+XoqgM8456cA+Axt4NlTa+LmJiYIgiCIE4kWWW445+/CiEWMXf8IgEc8dhvlcawggG+1pJ50I5xV+QHTuaU64wLz/QoabJEfEdFDzCaICaFIxP7FCmKi35hTEIt3iInlRl2D4ohMNHqIHT8WxsVDurlehxDVvHqIhVwcYqJuKzJRMa650RQAY3uICVFL1XT4FKfOKt7HYESzRS4aLjJFYlZfMi/qQioKAgpFLBEEQRBEB2Hf8WgvpDw/OcCJ1LjnsiF4ZObGbJeRNf6xaGe2S3Blf1Ujnp/vLjDtPdaAo/VhjOhTjHdX7U/reX/z9tdx6y58fAEevmKYI/bwaH0YR+vDAIB731+Pe9+Pd98RBHFCMQXABebyKwDmA7i7tYt4ZfEu+GQJ148lpzxBEARxgpHlBuP0BCIBQqASLi7RB0y2OcTsPcTCqtFDrCAQjSgMmftEHWJOsWjcKWXYVtEThTmKJT45BDGbuORXJDRGNIdIluOTUFUfQW1IRZ9mOMQCimRFEtqJPb84Z2MkXhAzIhONH+Swxh2RjvbzhyK6o4eYsW9yQaw2qKIwJ743GkEQBEEQ7R+/0qLAAuIEYmTf+Di8jkxFXSjtx/ztO/EiUku5/JkvPLc9MGM9Ptt0BHdMODnt5/Xi3vfWtdq5CIJo83AAnzLGOIAXOOfTAXTjnB80tx8C4D6zOMO8v3o/8gMKCWIEQRAE0crQE4gECPFKOL5CEWdkh/rRHwAAIABJREFUYn6sIKbp8MuSw/UVjUw0HWKKU5Qa1a8Uz1w3EpLEoj3EVM2KJrSLS5ZbS7b355JRawpavUtyXa8joUMsaQ8x2VGHcIjJDocYQ0TXwTk3IhMl78hEzRaZCBi9yCLJIhNDEUuUJAiCIAiifZLdOWBER2BUvxJcObIXAOCWcf2zXE3m2VFRn/ZjvvHV3rQfMxGfmb1qnp1HEYUEQWSFcZzzMwBcCuAOxth4+0azb73rVxTG2G2MseWMseUVFRVpL0xizHo+QhAEQRBE60GCWAICigy/LFlikNU/yxR88gIKGsLxkYml+X4AQGGO4hDE/LIESfKO/Qv4kjjE5Gg/sdh9ACToIRZ1rMXiV5IIYrYeYoDhEFMk5ogv9MkSOAc03RTEYiMTbUKfcIMJUVGWk38JrAupKMghQYwgCIIgOhovf+/MbJdAtDOe+PZw7Hz0G7j38lOzXQpBEATRxuGc7zf/PAKj3ccYAIcZYz0AwPzziMe+0znnoznno7t06ZL22iSJQc9yZBRBEARBnIiQIJaAHJ+EHJ9kiTei15Z4nedzOsQiZlzgqH4leOnm0TizvNQSh2qCkbi4xFjs0YJCfAvERCb6ZckhRgVsjjOvyEThcHOLHfQrknUuO2FNs7YDUVdaY0RzCHJA1O2lCkEsNjLRJvSpth5iAKBI0bhFL+qCKjnECIIgCKKdI749/OmTzda6IT06ZacYot3CWHRi1u3jT8JpvYqw7sFL8MGd43DWSaVZro4gCIJoKzDG8hljhWIZwCQA6wDMAHCzOexmAO9noz6JAWQQIwiCIIjWh1SGBAQUGTk+2RJ8RD8w4fLKDyiuPcQYY7hoiBFD7Tf3rQmqyHFxaMWeDzCcaMKh5YhMlCVHXCIQjXXM9ckoM51psZx7chmevm4khvWKf+jk84hMDFmRiWYPMVMYC4Y1R/8w+5iIpiOsNq2HmE9mUJNEJtaGVPT2EPsIgiAIgmgfuD3z6V6U0+p1EB2H335jiLV8Wu8iDOtZhCU7jmWxIoIgCKIN0Q3Au+YkCgXAvznnsxhjywC8xRi7BcBuAN/ORnESS/4shCAIgiCI9EOCWALGnlRqOsSiDicgKubk+mVHZGJY0+FTnGKREIfqgpEUBDEhHGmIaDpkiTncWH5FghInNhnH7FOa63CO2VFkCf8zvKfrtuSRiUK4Ms7bENbiahDvR0QzHGJ+ObaHWDQyUcQjiutSZGbFKHpRF1RRSA4xgiAIgiAIgiAIgiBSgHO+A8Bwl/VHAVzU+hU5kSkykSAIgiCyAkUmJuCGsf3w2DXDITQpIRKJuL98v4yIxhFWdXBuiEGBWLHI1kMs5chEs4eYP+ZYfkWKc1+JY3r1D0uG38MhZglisiFmCdFL9BCzI65R1YxIRE+HmKrH9RBTJCm5IBZSUUg9xAiCIAiCIIgE/HjCgGyXQBAEQRApwRhDku4RaePzLRU4d9pcBCNa8sEEQRAEkWGyPR2EBLEUYIxBkZiLQ8wQaRrDGlSdg3PEiUEi4rC2CZGJQhCLjUf0ySzOfZVj7tO7pHmCWMCzh5hwiJk9xERkoksPMSsyUeeIuEQmiusOqbrlEBMimiIljgnQdI6GsIaCQHz/M4IgCIIg2i+daLILkWZK8/0Y3L0w22UQBEEQRFJkBvBWcog9/OEG7K9qxJ5jDa1yPoIgCIJoy9CTiBSRJYaQqlnLgOEQA4D6sGpFJQrhSCDEosaIZolXXgR8wkmlIazp8MeM9ytyfGSiuU+f5jrETEGMc+6IXIxGJkqO62gIa3GCl+ixFlF1hDUdnfxO8coeBanGRSZKiCSYFlUXMiIpC+ihGUEQBEG0WyKajufnb3ese/HmM7NUDdGRef67o/Dyop24/fyTUZij4OO1B3H322uzXRZBEARBOJAYRSYSBEEQRDYgh1iK2B1isq2HGGCIRBHV+CITG3NoF49y/IkFMbFvWNURVrklJNm3x7rGhMjWpyS3SddjPybniIstjBXEfDZhL9YhZkUm6joimg5fzPao0KdbbjDhsvPJDKru7RATghj1ECMIgiCI9stnG4/ErRvTvzQLlRAdnf6d8/HQlGHoVZyLTjk+fOfMvta2339jSBYrIwiCIIgojDEkCMshCIIgCCJDkMqQIrLEEIo4BbF8MzKxIawirBmuqFiHmEMQUxLrj5LE4JMN4S2sxUcmXjqsOw5WNzrWDe3VCWP6l2JUv5JmXFVU8DIiGqP1WZGJshDEjFqCYS1OnBIxjhHN6KMW30MsGpkY6xCTJWbFKLpRFySHGEEQBEG0d1orEogg3Nj08GTIEoNPltC3LA+3/2tFtksiCIIgTnBkqfW+H9G3MIIgCKItke3HA6QypIgiSwjFuJvyAlGHWFRAiumvpURfJ+shBhjiUSiiI6xqllgluHpU77jxPYpy8dbtZzfhSpzYBbH8ALB4eyXeW7UfA7sVOrYLkasholkRiQJFMnuIaToiGo8TBa3IRFWL9hATDjFJQiTBtKi6UAQAUEAOMYIgCIJotzCWfAxBZIpUvoMTBEEQRGuSjcjE7/3jq1Y9H0EQBEG0RSgyMUUMh5izh1iezSEWMSMGY91RDoeYL/nbHVAkhFQNEY3HCWKZQNQnBL25G4/greX7rGarQswStWg6hyzFXKMiBDFuOs1iIhOtHmLxDjFFZlAT9BCrJYcYQRAEQXQAnN8NHr5iWJbqIE50SJsliPbJab2K0naskjxf8kEEkWEkljgtJ52I330HqoOtcj6CIAiCaMuQIJYiisSsvlrRyERbDzHN2XPL2s8hiKXiEJOMyERVj+tHlgnsDjEAqG40HFmr91YZ22WnQ8xYdj5KED3DIpoOVY+vmzEGv3ldmq5DkRgYE4KYhEiiyETqIUYQBEEQHY4bz+qX7RKIE5yRfYvj1u2adlkWKiGItsEgMyGktRjdhMj/x645HXdMODmlsd87pzzpmA9+Mi7lcxNEppAk1iqRUR+vPYitR+oyfyKCIAiCSJFst1QgQSxFZMno7SWWASBXCGIhzdoW7xBrWmRicZ4flXWhuJ5emUK4t4RDrMoUxDYcqIEiMUgi2tB2HeL6BUL0UzVuRCa61B1QJAQjGlSdO/ZXJAZNTxCZSA4xgiAIgiAIIk2UFQQAAGeWl2LaVafhnsuGmK+b14+XIDoKgRTSTARiUuXUSwdb63KbGE16/di+Cbf//OJTrOVvj+7jmHh62/iTrOX7Lj/VWn76upH43TeGYPzALo5jff/ccjw0Zaj1uldxrus5i3JTd45NPLUbfjlxoFlffGsDgkiGxACtFR4IPjVna8bPQRAEQRBNIdu9LUllSBFFYqgLaeay8WU83x6ZaPUQc95I2F/npBCB2L9zPtYfqEZxnh+FrSACifosh1iDIYipOkeeP3pTYxe5lBhBTIhlEV1HxEPIy/craAirkCWfY39FckYmcs4xY80BXDK0O3J8suUQox5iBEEQBNE+iWg6DlQ1ZrsMggAAjOpXgtduGYuxJ5XCJ0uYte4QAKAkz5/lygiiZYikkUSsunciRj48GwDw20sH49GPN1nb/nLtSLy7ch/6luVjxpoD+HxLhWPfr353EUKqjh++uhwzf3oeZIlB1XRMM4/xn9vOQkjV8ZM3VqI414/Nh2utfa8f2xfnDeiMPqV5uPyZLwAAV47shRcX7sSGgzWutV52Wg/Hg/zhvaOuzp5FOdbyWSeV4YoRPTFlRC9MGNwVAPDqD8agfOpMa8z93xwKzjmO10dwzoAyK60EAF7+/plYu68aP77gZKg6x0/eWIVLh3XHS1/sxNVn9MZDH24AAFx+eg8M6laIwT064fyBXeBXJGw7UovHZ2/BZaf3TPi+E4QbcitGJhIEQRAEEYVUhhRx6yEmHGL1YaPnFxAfmejoIeZPPmuuvHMeZq0/hIAio3NB5m/MYyMTqxrD1jZnTKJdEHO/xoiqI6zF9xADgLyAjPqwhjy/4nCI+WTJEhMBYGdlPX72n9V4/FvDcfWo3lYPMSE+EgRBEATRvnjogw3415Ld2S6DICzGndI55bGdCwKorAtlsBriROSsk0rxwo2jMfzBT+O2Tb10sCUybf/DN3Dy7z5Kerwbz+qHuyYOREm+3yEEAcCcu8bjvyv2Y8qInijJj95f/mBcfyiyhBvG9sXR+jB6FefirkmDAAB7jjXECWJdOxki1Kyfj7fWKbIUFzW69HcXY9OhGkx+aqG17oaxfTG0ZxE2HDDEr5F9i8EYw39uPwtHaoIY0LUQ5VNnYkz/UlTWhbCjoh6MAf/3o7Mxf/MRAIa7c9yAzvhiWyXG9C+zjl3eOQ9PXTvS87155jpjG2MMP7O5zgQTBnXFhEFdzesB/n7TaADAVWf0xhtf7bHGfe+ccowuL3XsO6BrIUWtEs2HoVUiE+3iNEEQBEG0BbKcmEiRiamiSNEZd8LhFFAkyBJDQ1i1BKX4yES7QywFQawsH5rOsfNofatEJvpjIxNNh5h9G+CMTFTk2MhE47Wqc0S0BA6xkApV1x191RSZQbXNihIC2OFao9lrTTCCgoBiRTcSBEEQBNG+WLjV+VD1o5+el6VKCCIeMcHNyyFGUWhEIl7+3pnN2q9/5wIU5fpw89nx/RR12xMCWWK4eEg3AMBvJg/Cl7+9EKNiem/N/9UFePiKYZbY9fb/Oxvv33GutX1A10JMvXQwhvTo5NjPJ0u4ZVx/5PjkuAjBOycMQNdCI1708tN74I0fntWk62Mw7t1G9i3GrmmXYWjPIgDAkB6F+OlFp+DZ688AAHTK8WFAV6N32eKpF+KV74/BU98ZgYsGd0V5WT7OLC/Fry+JxjL+5doRuO/yUzGkR7TfWV6SiZMXmq4xNwZ3T9w3TUQvvn/HuXFiGEG0FPHvhCAIgiCI1oUEsRSRJWaJRsLhxBhDnk9GQ1izXE6x7qim9hA7qUs+AMOxFes2ywT2yETOOaoaI9aNgd/DIRbbQ0xsC6kadB4vCgJAfkBGfUiDFtNDTI6JTGwIGy68IzXGTNwjtSHrZowgCIIgiPbHrqMNjtd9y/KyVAlBxDP+lM54aMpQ3PfNUx3rexXn4r7LT8V1Y/qia2EAw3sXue6/9oFJrVEm0UbpUxr/eTbr596if7n5+SfuEQd0LbC2ndHXiATsUZSDbw7vaYlaYp8zy0vRoygX028chXEDOmPqpYNxzsllKO+c7zjHqH6lGN6nGIlI1r/Lr0h49KrTAADfHN4TZ59clnB8LAO7FeCXEwfiuRvOcKxnjOGuiQPR06WHV8/iXOT6ZZzeuxgvfe9MxyRKQVlBAD8Y1x+MMZzu8W9SkGP2RGMemsOGhy7B+3ee677RpFdxLnZNuyzp+0kQzYExo2UEQRAEQRCtC+XQpYhd2LILOnkBGQ0hzRLLYsUgxhh8MkNE49aX8kSUl0VvaGL7kWUCny0yMRjREVZ1nH1yGTYdqkVASTEy0Xxdb/ZY8ynxdx35fgWHaoJQNQ6fPTJRkqDq0cjExojhEKswo2mO1ATRtRMJYgRBEATRUaC+oERbgjGGm84uj1u/aOqF1vJXv78YP31jFdbsqwYAfPqL8Zj05Ofo3zkfhTk+vHTzaNzyynJr/JQRPfH+6gMZr51oPndOGIC/ztvmWPfaLWPx3ZeWNuk4biEWg7t3ilv3i4sHYt7mI/jPbWfh0Y824q6JRjThDWP7IaJxjOxbjBlrDmDlnioUBHxWzB8A/GbyYJwzoAxnmg6lsoIAXrt1LADgR+ef3KR6AaQc8XfRkG5Y+JsJrqJfMhhj+MlF8fGE6eSt28+2JlO61mC6b7z0hmTOMoLINAwAyWEEQRAE0fqQQyxF7CKYYlvO9ytoiEQdYgEXV5cQk1JxiJXm+1GYY3w597WiQyyk6lb/sFO6FqJzgd/hUJMlZr0HSqxDzBTAgmaPNTchLz+goCFsOsRi4hfdHGIVtYYgdrgmhG6dckAQBEEQHRXG2GTG2GbG2DbG2FSX7QHG2Jvm9qWMsXJz/UTG2ArG2Frzzwtj9yUIIj2c2T8alzawWyHm/eoCvGc6eC4a0g1LfnsRAGBYr074S4J+RkTbwG3C3bhTOqO/zW0VGyP4z++fiVO6FmD6jaNw3Zg+uG38SY7xH/5kXJwjSjBlRE+8d8e5yPHJeHDKMBTl+QAAksTwg3H9MbJvCe6ePBh/uPI0XDzEGfHnVyRcOLhbs6+1JTRHDGstcnwySvO9e24LZxgJDkRbRWIs4z1U3lu1P7MnIAiCIIhmkO3vZzQtKkXsrii7OJbrl9EQ8u4hZuxrjE/FIcYYQ//O+fh6X3WrOMSEgBfRdFQ3Gv3DivN8GN2vFPVh1THWJ7M4QQuIvjdCzPKKTKwLqYjo3PFe+mTJEhPtx6isDYFzjkM1QRLECIIgiA4LY0wG8CyAiQD2AVjGGJvBOd9gG3YLgOOc8wGMsWsB/BHAdwBUAvgm5/wAY2wYgE8A9GrdKyCIjsW8X12AfH/8JLbvju2L3iW5Vq+x/jExdd2LcvDqD8ZgWC8jxq1rYQBHzAleiuTsmQsAV43shXdO8AeVp/bohA0HaxzrtjxyKQbe83HazrH1fy/FKb9PfrxLhhqCk31y42e/PB85PhkbD9age6cclOT7ccEgQ6yaNLS7Y3+/LGFYryLr71/QtzQPe445Y2O9yPHJSaMMm8KvLxmEMf1P3L5XMhMOsWw/ciEIdxhz9gxMJ8fqw3hn5T48MnNjRo5PEARBEC0h29/PSBBLkdi+V4J8v+LsIebi6hJOq1QcYgAsQczNbZZu/LbIxKoGUxDL9eFP3zodMfft8MkSghHdEXlorDdeCwHNTRDL8ytoCKnQdD3uvdRsJ2oUPcRqQ6hujCCs6tRDjCAIgujIjAGwjXO+AwAYY/8BMAWAXRCbAuABc/m/AP7KGGOc81W2MesB5DLGApzzUObLbh63jz8p2yUQREJihS4BYwwTBnV13SYYP7CLtfzV7y/GL95cjXdX7cdj15yOq87ojfKpMwEAf7l2BIrz/JYgtvmRybjkyc/j+u11dD762Xm49C8LsdEmiiXqofyHK09D75JcVDdG0LUwgF1H63H322s9x6+8dyJ8soSyfD+O1htJGDeM7YvXl+4BixnXyUzo+OWkQfjhq8sxql+Jde82pEd8BKKdL397IXIU9/u8U3t0wp5jDchzEVkzzR0TBrT6OdsSb/3obMxYc4Bieok2C2OZmyF/6yvLsHJPVYaOThAEQRDtG4pMTBHFo4dYrl9GQ1hF2Iz9c3N1NSUyEYj2EXMTltJNwLx5C6qaJYgV5flQmONDUa7PMVZcmxzbQ8xc32g5xFx6iAUU1Ic1hFXuiFxUZIaIHh+ZWBdSsbOyHgDIIUYQBEF0ZHoB2Gt7vQ/xLi9rDOdcBVANoCxmzNUAVnqJYYyx2xhjyxljyysqKtJSeHO448IT+wEtcWIhItu0mFlm/TvnY2z/Ulw8pBvm/vJ8BBQZA7sVOsZcNbLtmz3fv+NclCWIrEtEiRkZOKJP1FF1z2VDAACf/Hw87v/mqXH7XD+2L8YP7IJvDu+JsSeV4YJBXa0eXleN7IVd0y7DdWP6AABuG3+SFac3/aZRAAxh61ujje3nD+yK8QO74LkbzkBpvh+KeT9TbNYVex+UiB5FuSiJeR+W/u4ifPX7i/DEd4bjrdvPRle6n2l1hvTohLsnDwZjLo3eCKJNkLnIxFSdqQRBEARxIkLTpVLE2UMsKgjlB2Tsr9KsyMSEgpjHzMFYxMzURDMk00VZgR8SAw5VBy2hqjjP/cZWiIKxgpdYXx9KEJlozoqsC0Uc76VPkqDaIhMbbTGN6w8Ys0VJECMIgiAIbxhjQ2HEKE7yGsM5nw5gOgCMHj261fIJ6kLO+OVOOak/ZCaI9k40ss25/vTexQCAF28eba2LfWZ/7Zi+uPvSwRj7h89cj/31A5PgkyQMuW+W6/aJp3bD7A2HU661S2HA6uGb55etSWqC759bjvEDuyAU0fGj11YAAIb3KcapPTth4dZK12PumnYZAODRjzbihc93OLZ9afZc+8XFA/HGV3tRlu/HrecZDtJB3QtRku/Dgx9EjbI3nd0v7vjdOuVgx6OXuZ67X1m091XnAiNtYmC3AozoU2zV9eoPxsTtN7pfCX45cWCLowvt9y8ncmwhQRDeGJ/7mflKVlkXzshxCYIgCKIjQA6xFFE8IhOLcn2oaojYIhPjZ6AJASmVHmJA6wpiPllCj6Jc7D3W4IhM9BoLOK8fMEQtAGiMeEcm5ptRFTWNqjUDEzDENJ0Dujlz1n7zvW5/NQCgm0vTa4IgCILoIOwH0Mf2ure5znUMY0wBUATgqPm6N4B3AdzEOd+e8WqbwIrdxzHs/k+yXQZBZA3JVLlS6REztKez9xRjhqgy/cZR1rqvfneRtdwpx4dcWwzfe3ecay2//f/OxlPfGYFzTo41kgILfzPB9fzTrjrNWl7/4CX44u4JVgTktKtOw/3fHIoJg7pi8rDu6G4Te+yXtu7BS6zld358jrX860sG4YUbR2Foz2j0oEjOEPcVse+QEM/7lOa61uvFt00H2PhTovGV/cry8e9bx2LaVacn3Z8xhp9cdArKCuj+gyCIzMIQP2GCIAiCIE4Esv37r0WKC2PsW4yx9YwxnTE22ra+nDHWyBhbbf7/N9u2UYyxtYyxbYyxp5mZYcAYK2WMzWaMbTX/LGlJbenG6RCLLnfvlIvKuhDqzRnQ6YhMPKlLPgoCiuNmM5P0Kc3F3uONqGqMwCczz4x7cW1KjCAmSQyyxCwxyz0y0ThmdWPEGZloLotG4w0RmyB2wBDEuhaSQ4wgCILosCwDcApjrD9jzA/gWgAzYsbMAHCzuXwNgLmcc84YKwYwE8BUzvmiVqs4Ra5+fnG2SyCIrNKj2PgOK+L3/nr9SIzoU+w69o4JA/Cna05HoTmJTHxbnjS0uyUkucXuXTCoCy4e0hUj+hRj0qnd8OtLBmFUv1LkBxT0KcmLG9+nNLrut5cOtpbtCRGMMfQuycPJXdxj3D/5+Xgs+PUFxjUW2cUx4/t8vl/GGX2jt3KKLOGSod3x04tOAQCUl8XXFdtYO8cnY9e0y3DruJPM7XG7uDKybwl2TbvMcZ0AcM6Azg4BkSAIIttksocYQRAEQRDetDQycR2AqwC84LJtO+d8hMv65wH8EMBSAB8BmAzgYwBTAXzGOZ/GGJtqvr67hfWlDXtMomQTdMSN7t5jDWAs3j0FRJ1eqQpihTk+LJp6oXVDnGn6lORhwZYKDOxWiKJcv2fOurgZVlxEP8UuiLk42/L9wiEWQa+S6ExPcSxV1+GHhMawZsW0bD5Ui045Ct28EgRBEB0WzrnKGLsTwCcAZAD/4JyvZ4w9BGA553wGgJcA/Isxtg3AMRiiGQDcCWAAgPsYY/eZ6yZxzo+07lWkxu3nn5TtEgiiVbljwgD075yPycO6AwAuP70nLj+9p+tYWWL41ug+GNitEL9/b63DMfbOj89BxOxXPPXSwehnE3v++f1o7N/0m6IRjABwWu8ivLl8L2K58ax+KM334/bzT8as9Yewak8VAOCnFw7AvM3RHoO/mjQIxbl+TBnhrLkoz4cis9fWg1OGolunHJw7oDN0MwXdK35d3A+MLo9GCCbr7yQ2c3psTBBEB0NiLG4yAEEQBEGcCOw9nt1ely1SXDjnG4HkNzICxlgPAJ0450vM168CuAKGIDYFwAXm0FcAzEcbEsS8HGI9iwxxZ9fRBvhkyfW9EONzUxTEgKY1cm4pfUrzcKQ2hIraIIpyvX8kRBxkrEMMMNxjjaYg5uaSE5GJtSHV1SEmbvIbwip6FediR2U9IhpHeRm5wwiCIIiODef8IxiThOzr7rMtBwF8y2W/RwA8kvEC08TPLxqY7RIIolXxyRKmjOjVpH2G9ynGhz85z7EuoMgQ8+R+dP7JKR/rhrF9cc976wAYUYmi7+/DVwyzxpzRtwSr9lShLN+PuyYNwl2TBlnb8gMKfnbxKQnPkedX8KtLovvcc9kQTDq1u+vYcweU4aEpQ3HlyOh7IlIkbhnX33Wf03oZwuDZJ3VOWAdBEER7gwHQSQ8jCIIgTkBEm6RskUkLUn/G2CoANQDu4ZwvBNALwD7bmH3mOgDoxjk/aC4fAtDN68CMsdsA3AYAffu2rOFxqnj1EOtpOsR2H613FYKAqLMq0Ao9wZpDb9Oxtf5ADXoWe+f0e/UQA4xeYA1h7x5i9hhGN3FRs/UQyw8oKMv340htyNGQmiAIgiCI9gs5vgmidWGM4b07zoUisbgIQcHUSwfj26P7oNzsYdxSbj3P2wnKGMNNZ5c71gUUIxrRi5F9S7Dm/kmtOlmQIAiiNWDkECMIgiCIrJBUoWGMzWGMrXP5f0qC3Q4C6Ms5HwngLgD/Zox1SjDeATe+FXh+M+CcT+ecj+acj+7SpYvXsLTi5RDrYTrEjjdErGjEWPyKBL8iOaIW2xLiBvlgdRDFCW42E0YmylLCHmIFtvhHh0NMRCZqRsaKiEzsUmg0su7aiRpaEwRBEARBEERzGNGnGMN6FXlu98kSBnUvbMWKmg6JYQRBNAfGWB/G2DzG2AbG2HrG2M/M9Q8wxvbbet5/I1s1plsO23O0Ieuz7gmCIAiirZPUIcY5v7ipB+WchwCEzOUVjLHtAAYC2A+gt21ob3MdABxmjPXgnB80oxXbVP8LRXZ3iOX6ZZTk+XC8IeIqBAHGjWZOG3WHAXA03Bb9ANwQDjivyMS6UAKHmF0Qs20X71nE5hArzvMhoEhYD5BDjCAIgiAIgiAIgiCIpqIC+CXnfCVjrBDACsbYbHPbk5zzP2exNqNHYpoVsfF/mpfeAxIEQRBEBki1/VamyIhKwxjrwhiTzeWTAJwCYIcZiVjDGDuLGVd+E4D3zd1mALjZXL7Ztr5NIEQwicX/pQmXmJsQZKxnyGlC/7DWpmthwHLVlSwdAAAgAElEQVS3Fee6N8EGouKVV2Rio+UQi38fCvweDjEpxiEW0ZDrVyyHWLdCcogRBEEQRHtn40OTs10CQRAEQRAnEJzzg5zzleZyLYCNiLbsyDoMLO0OMYIgCIIgktMiQYwxdiVjbB+AswHMZIx9Ym4aD+BrxthqAP8F8CPO+TFz248BvAhgG4DtAD42108DMJExthXAxebrNoMQbsSfdkTfLa/IxByfjPxAJtu1tQxJYuhtXkNxAoeYcHa5OeEUiSFsilpu23O9eoiZY1XLIaYizxeNTCSHGEEQBEG0f9pqH1WCIAiCIDo+jLFyACMBLDVX3ckY+5ox9g/GWEk2apIYqIcYQRAEQWSBFqk0nPN3Abzrsv5tAG977LMcwDCX9UcBXNSSejKJEHHc3FE9iw3Rxu/hEPvxBQNwtC6UueLSQK+SXOyorE8oiInrk11EQZ8jBjF+u1+R4JclhDXdwyEWjUzM9cvoWmi8p11JECMIgiCIdk9b7aNKEARBEETHhjFWAOP51M855zWMsecBPAwjsPBhAI8D+IHLfrcBuA0A+vbtm4G6AD2NehiJawRBEASRGjRdN0WEk8mtf1ayyMRB3QtxzoDOmSsuDfQpNfqIJWpa7UvwHtiv3csplx8wXGJ2QU28rxERmRjWkOeXMbq8BKf26IRTuhU05TIIgiAIgiAIgiAIgiDAGPPBEMNe55y/AwCc88Occ41zrgP4O4Axbvtyzqdzzkdzzkd36dIlE7WBtzA08Xh9GMfrwwCAJ2ZvSUdZBEEQBJFxsj2JgwSxFBEikNsMZ+EQc4sKbC/0KUlFEDNjI12u037tXsJgntlHzC6o+WyRiWFVh6pz5PllDO1ZhI9+dh465XjXQxAEQRAEQRAEQRAEEYvZt/4lABs550/Y1vewDbsSwLrWrg0AGICWPg8c+fBsjHx4NgDgmbnbWl4UQRAEQZwAtN3GVm0M2eoh5u0Q83JGtQfKywxBrHNBwHOMT/F+DxRHZKK7MFhg9lGzC2rifdV0HY1hDQCQ66cfS4IgCILoKLxw46hsl0AQBEEQxInHuQBuBLDW7G8PAL8DcB1jbASMyMRdAG7PSnUMLfSHEQRBEATRHEh5SBElhR5iXs6o9sDEU7vhb98dhaE9O3mOET3EFNceYik4xMzIRIdDTBKRiRwNEdUY55ebWD1BEARBEG2J2RsOW8uXDO2exUoIgiAIgjgR4Zx/AcOIFctHrV2LG4wUMYIgCOIExTBxZw8SxFJECGFu7qhunXLAWFQwao8osoTJwxI/sLJ6iLlGJkquy3aEQ8zZQ8xYVjWOBtMhRoIYQRAEQbRvfvjq8myXQBDE/2/vzsPbqs48jv9eLZbt2HH2kLVZyEJCSACzBEhYkoYktBNoWYcWSulQhnYodKFAGYYpMNB2Spdppy0tlLbTsnShZVjKUrYyQCCQAGEJcRZKUkicBEJWL9KZP3SlyLYky7Ys6crfz/PosXx1Zb3n3JN7T/Tecw4AoGQFTD1eQwwAAHSdfzM4BZZtDbFwMKBhtRFfjxDLRaJ86UbJJUaNBSz969K+RFdqQi3xvCV1ysQwCTEAAPxqZ1NrsUMAAAAoaWZSjHwYAAAFxwixHGUbISZJX1owRSPqKgsZUsGFc5gyMVtSsF9FYoRYSkLMex5tM0KMZgkAgF+d/dNnix0CAABASTOZnMtPRuyTtyzNy98BAKAvIPOQo2xriEnS6fVjChlOUVSEEgmxzFMmZps2sp83ZWKoTULMmzIxFtPu5vgd5VVMmQgAgG+9tGF78vnTl59QxEgAAABKk+VxCbG/rt6Sp78EAED5IyGWo2CW0VF9RTIpmGYNscTUh+FQ5vqpjnhTJgZS1xvzpkyMOjnHGmIAAJSTkQOqih0CAABAyTFJeRogBgAAuqDvZne6qLMRYn1BYhRYOE1SMDEyLJwmWZZQ402F2HYNsdQRYiTEAADwqzWNOzXlqgeKHQYAAEDps559t/Tmph15CgQAgMIqdnaFEWI5CpIQS47+SlcHoRzWEKuOZF5DrDXqtLc1JokpEwEA8KN5336i2CEAAAD4QuJbEeecrBvJsQ3v7c5vQAAAFMjyt98v6uczQixHjBCTKrykVyjdlImBxAixLGuIVSSmTEwdIeYlxGJOe7w1xKoryNMCAOB31518YLFDAAAAKEkBLwnW3WkTm1uZbxEA4E/RWHGvYSTEcpRIhIX6cEIsnFxHrWMdVIQ6nzKxX9oRYt6UidF9UyZWhRkhBgCA351eP6bYIQAAAJSkxKCwWDczYjubWvMYDQAAfQcJsRwlEjd9eYTYvoRYx2aTSJJlHSEW6ThCLNxmhFhUkVCgT9cxAADlInGzDAAAANpKTplY1CgAAOh7mJsuR8kRYllGQJW7EXWVCgZMg2sqOrwWCuYyZWKozb7SvnptjTrtbo6qmvXDAAAAAABAGUuMEOvqALHWaEzbdjXrvx9vyH9QAAD0ASTEcpQYyRToxmKn5aJ+3CC9cNV8DajumBBLrC9WkXWEWMcpExMJtJZYzEuI0SQBAAAAAED5ssQaYl0cI3btva/pF8+81RshAQDQJzCXTY5YQywuXTJMShkhFspcP4P6xd9bG9mX9AqljBDb09KqKkaIAQDgew9dOrfYIQAAAJSs1mg8EdbVEWIPv7apF6IBAKDvICGWo31riFFl6YRzmDJx5IAq3X3RUZo/bXhyW3LKxBhTJgIA4Fev/f2DNr9PHl5bpEgAAABK33ceeVOS9Ldtu4scCQAAfQvZnRwxQiy7xJSSoU4ShgePHdgmaWZmCgVMrdEYCTEAAHzqhbe2FTsEAAAA39m6sznnfZtao/r79r29GA0AAOWPhFiOQl7CJ0hCLK1EIqwiy5SJGd8bNLXGnPawhhgAAL5UEdrXpXzmihOKGAkAAEB5mnLVn4sdAgAAvkdCLEeJRBgJsfQSI8SyTZmY8b2BgFqiMe1uZg0xAAD8KHWE+Ii6qiJGAgAA4B8vbXg/p/1cVxcbAwAAaZEQy1GIKROzymUNsUyCQVM0MUIsTEIMAAC/SYykBwAAQOc+ddQ4SdK4wdWd7huLOX3tjyt7OSIAAPoGEmI5YoRYdqEejBALBQJqiTrtbmENMQAA/KjCu/4PqA4XORIAAIDSVz9uoCRp667O1xD7n6Vv6TdL/9bbIQEA0CeQEMtRYiog7oBOL5EIq+hG/YSDpsYde/X+7hYNr6vMd2gAAKCXBbwbhm7+ZH2RIwEAACh9iRkQ33hnR6f7kgxDNm9cu7DYIQCAr5AQy1FiZFjASIil05M1xEJB0/Pr35MkHTp2YF7jAgAAvS8ai3+rU1fFCDEAAIDOHPqh+Hcf00b273TfN97tPGmGrjnt0NFd2v9HZx+if/3INP31suN1/8VztPTKeXrzukW9FF1bD106V7WRkCTpmo9Oa/PaP80Zr8pwUN87c1aX/+6kYTV5iQ8A/KZHCTEzO83MXjWzmJnVp2w/28xWpDxiZjbLe+1xM1uV8towb3vEzO40swYzW2pm43oSW76xhlh2yTXEQt2bMnH7nhaFg6aZYwbkOzQAANDLbn8ufucyU0sDAAB0rp+X4Hh+/baM+6zetEPHfuuxQoVUdg4bN1AXzJ2gIycMSm677bzD9Mo1C3TVSW0TSy/92wL9+BOH6s+XzNG6GxZr3Q2L9Z0zZkqSvvnxg7Roxgidf8x4jRlUrWkj+2t4/0pVhAJ6/esLdeqhozWkpkILp++nzx47QdNH9tea/1ic/NtPX35Cm8/6xyPGStp3Y3lCXVVYB4xomyD95qkHafLwWt352dnqVxHU4hkjtP7Gk3TLufGvYKePrJMkLTxwv7R1MH1kfz3+5eM6bP/pOfW65/PHdNiebl8AKDehHr5/paSPSfpJ6kbn3K8l/VqSzGyGpD8651ak7HK2c25Zu791vqT3nHP7m9mZkr4h6Ywexpc3+9YQY1BdOokpJcPd+CIskWScPrJOlWHWEAMAwG8SX+a0/489AAAAOqrxEmJ/eHGjbjq94+ielmhMH/7Ok4UOq+hu+NgMXfGHV3La96+XHa/7XnlHQ2siWrtlp3759Fv6+KGjdcT4QZp3wHBVdHLD9vobT9Iza7bqsVWbVVcV7pBUOuXg0Trl4OwjyaoqgvrP02a23egNHGu4fpF2NUVVVx3WxKH9tKZxl567cp6G9a/UWYeN1bD+Ef155bs6eOwArduySyfNGKFQhlmXpo3sr1e/vm9qxHkHDNfDl87VpOG1kiRTvA8+oq5Sz1wxT+Muv0+jBlTpvovnSJL++biJ+tHja7Rk1kh994xZMjM1t8YkSYtn7Kf7X3lXkjRuSD9du2S6Rg+q1nk/f15SPLH4/Pr3dOGxE3X5oqkad/l9Gevj7ouO0oShNZr57w9Jio9CW715p+YfMEw/O/ewrO8FgELpUULMOfe6JFn2aQTPknRHDn9uiaRrvOe/k/QDMzPnEjMrF1di7TDWEEuvZ1Mmxt+TmDIAAAD4S6K3luk/8QAAANgnGDDVVYV10kEjOry2pzmqL961Is27yt9Zh4/NmhBbdd1C/Xnlu4qEghozqFoXHjsx+dpXTpza5c+bPXGwZk8c3K1YOxMKBlRXHe8b33fxHDW1xpLTi88YHR/Zde5R4yRJB43u+mxJiWSYJFWEAvrWqQcly7L+xpPa7Hvp/MmaMrxWS2aNTH6HWxEK6KmvHq+htRFdduJeVUfiN6h/cnY8pl9/5gjd/8o7uv6UGWrc0aRB/SokSS9cNV/N0Zhe3rBdf3l9k+5atkHXnnygFh+4nwbXRCTFk5VL123Tirff0+rNO3X9KTMkSQumDdfSddu0fU9Lh/JM3a9W3z/rYC3og4lgAIXV0xFiuThD8WRXqp+bWVTS7yVd5yW9Rkl6W5Kcc61mtl3SYElbChBjp1hDLLueTJmYSKbVkxADAMCXEncvMbU0AABAbgbXVGj77o6JgQOu/nMRouk9AZNiTrr3X47RR/7rKUnStUum6x9mjdKLb72n8257XrMnDE4mB9snc6IxpydXN+r4KcMkSUtmjSpsAfKgMhzs9RmRTqsfk/G1ilBAJx/csd5GD6yWFB8Z1t7R+w/R0fsPkSQNrY0ktyeSXiPqqnTi9P107ckHKhJqW7Yxg6o1ZlC1lswaqU8dNV7D+1dKkm4+Jz7V4+7mVjXuaNKjb2xWw+ad+tRR45IJvvbHX5JueOB1Dayu0Pgh/fS9R1brZ+fWa+SAKu1ubtXLG7brC3cs16YPmtS/MqSXrzkxXiZvNNrTl5+gITURfeJnS7VlV5PWNu7SV06cok8fPV7n3facnl0bn+nikS/O1f7DatWweYfm35Q9KVcZDmhvS6zNtuOmDNXjqxqzvg9AXFWRZ4jrNCFmZo9ISjcZ7decc3/q5L1HSNrtnFuZsvls59xGM6tVPCH2SUm/7ELMMrMLJF0gSWPHju3KW7stMSUgX/SkF+rBCLFEspERYgAA+FNiQD/9JAAAUOrMbKGk70kKSvqZc+7GYsQxtCaiTR/sbbPt7uUbihFKB3MnD9WTb+b+5f6tn6rX0rXb9JMn10qSLjpuoi798GQ1tca0Y2+L1mzepQNH1enN6xapJRpLrqF2/NRhaRMgqYIBSybDUHraJ8NShYMB7T+spsP26oqQPjQ4pPOOHp/TZ1yx6IDk8xOn7/uKuroipCMnDNbSK+fruXXbNGW/faPm/nrZ8dq+p0UjB1RJku66cHaHv3vHBbP1kyfWaPbEwdp/WPy9iZ+S9NLVC7R5x95ksu6R1zZp664mnXHYWDnntPzt9/XMmq1aeOB+mjg0Xs7te1oUCQX04yfWaOLQGn105kjdvXyD/vDiRi1b/55+e+HsZGJ45pgBmjaiv55qaNTb2/borMPHaM6kobro1y965Qtqd3NUknRG/Rg91bBFG9/fk7aOvr5kuq7+06vJ34/Zf4ieaiiJMSZAB5+Zk9u//d7SaULMOTe/B3//TEm3t/t7G72fO8zsN5IOVzwhtlHSGEkbzCwkqU7S1gwx3SzpZkmqr68vyJSKiYQPi8Wnl0iEVXRjSslwMKAxg6o0zLtjBAAA+EtLNJEQY8pEAABQuswsKOmHkj4saYOk583sHufca4WOZVdzq1Zu/ECStGNvi2Zc81ChQ8joJ584VP/70t912e9flhSfPu/7f1mtpeu26eRZI3X9KTO0atMO/XbZBp1WP1qHjB2oE6YO11cXTtV7u5uTo4jCwYBqIiGNqIsnJSpCgU7X9gK64/Dxg9r8PmZQtTKPmdvnsynTbiY0XL9IATMFAqa66nBy+/xpw5PPzUyHjB2oQ8a2vbk/MS3mJfMnJ7e1X49u/Y0n6f3dzepfGVbA+565NRpLTj+/7obFati8U/sPq1HjzibVRsKqDAeS0122RmNq3Nkk56SB1RWqqognJc+ZPU5Pr9mizR80pR0RGI05RWNOu5pa9diqzTpgRH817mjS3MlDJcVH1X3s4FEaP6SfzjpirIbURPTB3hZ99+HVmjNpiOZOHqrWWEyhQEDrtuxSayymJ1Y16oYH3tAl8ye1KfO2Xc16qmGLLr59ue67+BitbdylI8YP0vK339eJ0/fTfS+/o6G1ER0+fpCeXbtVl9yxQjedPlMDqisUc04BM7XGYtr8QZP+7Z5X9YV5k9S4s0kj6ip108Nv6vZ/OlLrtuzS+q27tPH9Pbr1qXV69op5un/lu5oyvFa3P/c3Pb1mi/70uWP0xxUb9ZfXN+kTR35I337oTf1t227NmTREn5kzQXVVYZ38w//TzZ88VJOG12rdlp3a3RzV53+zPH7MDxiuxh179dKG7W3q8sgJg5KjCyXpysVT9R/3v+Ed71G6e/nGDvWfzqePHq9b/2+dJOmqkw5QbWVIj69q1AMr383p/X71pQVTivr5lo8luszscUlfds4tS9kWUHwKxDnOubXetpCkAc65LWYWVjxZ9ohz7sdm9jlJM5xzF5rZmZI+5pw7vbPPrq+vd8uWLetstx7b3dyqaVc/qC99eLL+Zd6kXv88v1m3ZZeO/8/HdePHZujMw7s2au+hV99VNOa0aEbHubMBAOXBzF5wztUXO45S1NldymYWUfzmoUMVv1noDOfceu+1KySdLykq6WLn3IOdfV5v9J0SU5K8ce3CXp8OBgCAvoC+U+8ws9mSrnHOnej9foUkOeduyPSe3vre6dhvPaa3tu7O+9+V4qNJ7lz2tn7wjwdr6n61euLNLbr23n05v/FD+mndll2qCge1pyU+AmXmmAH6+CGjNHP0AM0cE1/TqiUaU2vUJb9wBwDkprk11qMbALbujK/dZzku37S3JapQwDqs6723JapgwNQSjam6Yt/YqD3NUUVCAW3f06KB3hqBXeWc0+YdTeoXCakmkn7clXNOzimZ/O1NufaderSGmJmdIum/JA2VdJ+ZrUh0KiTNlfR2IhnmiUh60EuGBSU9Iumn3mu3SPqVmTVI2qb46LKSUREMqK4qrGH9I53v3AcNqanQ8P4RTUwzFLozC6anm5ETAIDyl+NdyudLes85t79309A3JJ1hZtMU7y9NlzRS0iNmNtk5Fy1sKaSPzhyp/33p7yTDAABAqUuuX+/ZIOmIYgTy4CVzNfVfu7deWE0kpJ1NrRo1oEpfmDdJz67dqjMOG6N+kZCG1EQ0rDair588PTmd3f7DanX+MePlnNP2PS0aUJ3bl5/hYEB07wCg63o6GjYx0jZXmf4vntjefpmjxI0O3U2GSfGRksM7mfHNzJRjTq9gepQQc87dLenuDK89LunIdtt2KX53c7r990o6rSfx9KZQMKAnv3K8+kXoCaRTWxnW0it7MrsmAAB90uGSGlJG098haYmk1ITYEknXeM9/J+kHFr9NbImkO5xzTZLWeTcVHS7pmQLFnnTT6TN13ckHFvpjAQAAekUh1q6vDAc7rJ+VGJHVuKNJIwdUKhQMKBZzMpNiTgqY0o4WOP2wjpPDRQIdv78ys5yTYQAAlCMm7u2Cuupwh2GHAAAAPZDuLuX2E74n93HOtUraLmlwju8tiLA3kh4AAKDEJdavTxjtbWvDOXezc67eOVc/dOjQggUXDgZUVRHU2MHVye+fAgGTmSno/QQAAN1HdgcAAKDMmdkFZrbMzJY1NjYWOxwAAIBieV7SJDMbb2YVik8/fU+RYwIAAAVCQgwAAKB4crlLObmPmYUk1UnamuN7JRXvLmcAAIBS4o22/7ykByW9Luku59yrxY0KAAAUCgkxAACA4snlLuV7JJ3rPT9V0qPOOedtP9PMImY2XtIkSc8VKG4AAABfcs7d75yb7Jyb6Jy7vtjxAACAwgkVOwAAAIC+yjnXamaJu5SDkm51zr1qZl+XtMw5d4+kWyT9yswaJG1TPGkmb7+7JL0mqVXS55xz0aIUBAAAAAAAoMSREAMAACgi59z9ku5vt+3qlOd7JZ2W4b3XS+LOZgAAAAAAgE4wZSIAAAAAAAAAAADKGgkxAAAAAAAAAAAAlDUSYgAAAAAAAAAAAChrJMQAAAAAAAAAAABQ1kiIAQAAAAAAAAAAoKyZc67YMfSImTVKeqsX/vQQSVt64e+iLeq5MKjnwqCeC4N6Lox81/OHnHND8/j30E30nbqN8vkb5fM3yudvlK976DuVCPpO3Ub5/I3y+Rvl8zfK1z059Z18nxDrLWa2zDlXX+w4yh31XBjUc2FQz4VBPRcG9YyuKvc2Q/n8jfL5G+XzN8oHpFfubYfy+Rvl8zfK52+Ur3cxZSIAAAAAAAAAAADKGgkxAAAAAAAAAAAAlDUSYpndXOwA+gjquTCo58KgnguDei4M6hldVe5thvL5G+XzN8rnb5QPSK/c2w7l8zfK52+Uz98oXy9iDTEAAAAAAAAAAACUNUaIAQAAAAAAAAAAoKyREEvDzBaa2SozazCzy4sdTzkxs/Vm9oqZrTCzZd62QWb2sJmt9n4OLHacfmNmt5rZZjNbmbItbb1a3Pe99v2ymR1SvMj9JUM9X2NmG702vcLMFqe8doVXz6vM7MTiRO0vZjbGzB4zs9fM7FUz+4K3nfacR1nqmfaMbvFr36kr/ZJs5xszO9fbf7WZnVvE8uSlP5CpPGZ2qFdfDd57rQTK1+XzVqb2ambjzWypt/1OM6soXOnyew0sxWOYz2tPKR5DM6s0s+fM7CWvfP+eLSYzi3i/N3ivj+tuuYtcvtvMbF3K8ZvlbfdV+0yJIWhmy83sXu/3sjh+KC1+bgtG38lX57UM5SuL6673+fSdfHwMjb6T7/tO5td+k3OOR8pDUlDSGkkTJFVIeknStGLHVS4PSeslDWm37ZuSLveeXy7pG8WO028PSXMlHSJpZWf1KmmxpAckmaQjJS0tdvx+eWSo52skfTnNvtO880dE0njvvBIsdhlK/SFphKRDvOe1kt706pL2XJh6pj3z6PLDz32nrvRLMp1vJA2StNb7OdB7PrBI5elxfyBbeSQ95+1r3nsXlUD5unTeytZeJd0l6Uzv+Y8l/XOBy5eXa2CpHsMs5SuLY+jVaY33PCxpqVfXaWOSdJGkH3vPz5R0Z3fLXeTy3Sbp1DT7+6p9psT9RUm/kXRvtjblt+PHo3Qefm8Lou/kq/NahvJdozK47nqfSd/Jx8dQ9J3a7++r9ul9vi/7TYwQ6+hwSQ3OubXOuWZJd0haUuSYyt0SSb/wnv9C0slFjMWXnHNPStrWbnOmel0i6Zcu7llJA8xsRGEi9bcM9ZzJEkl3OOeanHPrJDUofn5BFs65d5xzL3rPd0h6XdIo0Z7zKks9Z0J7Rjbl1nfq6vnmREkPO+e2Oefek/SwpIWFDlrKW38gbXm81/o755518f+9/FIF7rPl6Tqctr16d1OeIOl33vsL3ifN4zWwJI9hHq89JXkMveOw0/s17D1clphSj+vvJM3zytClcvdysZKylC8TX7VPSTKz0ZJOkvQz7/dsbcpXxw8lpRzbAn2nEj2v0XfqEJevjiF9pw4x+eraW+59Jz/3m0iIdTRK0tspv29Q9pMNusZJesjMXjCzC7xtw51z73jP35U0vDihlZ1M9Uobz7/Pe8OZb7V9U35Szz3kDaE+WPG7aGjPvaRdPUu0Z3Sdn9tHV/olmcpZ6uXPV3lGec/bby8FXTlvZdo+WNL7zrnWdtuLoofXwJI/hj289pTsMfSmjVkhabPiX1asyRJTshze69sVL0PJnmval885lzh+13vH7ztmFvG2+bF9flfSZZJi3u/Z2pTvjh9Kht/bAn2nffxwXsukLK67qeg7SfLhMaTv5Ou+k2/7TSTEUGjHOOcOkbRI0ufMbG7qi15GO1u2HN1AvfaqH0maKGmWpHckfbu44ZQHM6uR9HtJlzjnPkh9jfacP2nqmfaMvqZP9UvKrTyesjtvlfs1sJyvPc65qHNulqTRit/ZOrXIIeVV+/KZ2YGSrlC8nIcpPpXPV4sYYreZ2UckbXbOvVDsWIASR9/J/8rmuptA38m/x5C+kz/7Tn7vN5EQ62ijpDEpv4/2tiEPnHMbvZ+bJd2t+MluU2KKM+/n5uJFWFYy1SttPI+cc5u8C1xM0k+1bxo56rmbzCyseGfv1865P3ibac95lq6eac/oJt+2jy72SzKVs9TLn6/ybPSet99eVN04b2XavlXxaUlC7bYXVJ6ugSV7DPN07SnpYyhJzrn3JT0maXaWmJLl8F6vU7wMJX+uSSnfQm86J+eca5L0c3X/+BW7fR4t6R/MbL3i0/KcIOl7KsPjh6LzdVug7+Sr81pa5Xbdpe/k/2Mo0XfydvNT+/R1v4mEWEfPS5pkZuPNrELxhd7uKXJMZcHM+plZbeK5pAWSVipev+d6u50r6U/FibDsZKrXeySdY3FHStqeMpQcXZToZHlOUbxNS/F6PtPMImY2XtIkxRe7RBbeHMK3SHrdOXdTyku05zzKVM+0Z3STL/tO3eiXZDrfPGEm/JkAAAIwSURBVChpgZkN9KYrWeBtKxV5KY/32gdmdqR3DjlHJdBn68Z5K2179e4efkzSqd77C94nzeM1sCSPYR6vPSV5DM1sqJkN8J5XSfqw4mt9ZIop9bieKulRrwxdKnfvlywuQ/neSPnC0RRfJyL1+PmmfTrnrnDOjXbOjVO8bh91zp2tMjl+KCm+bQv0nfx1XsukXK67En0nj2+PIX0n//adfN9vcs7xaPeQtFjSm4rPW/q1YsdTLg9JEyS95D1eTdSt4nOG/kXSakmPSBpU7Fj99pB0u+LDpFsUn1f1/Ez1Kskk/dBr369Iqi92/H55ZKjnX3n1+LJ3ch6Rsv/XvHpeJWlRseP3w0PSMYpPZ/CypBXeYzHtuWD1THvm0a2HH/tOXe2XZDvfSPq04gsAN0g6r4hlykt/IFN5JNUr/h+2NZJ+IMlKoHxdPm9laq9em3jOK/dvJUUKXL68XQNL8RhmKV9ZHENJB0la7pVjpaSrs8UkqdL7vcF7fUJ3y13k8j3qHb+Vkv5HUo0f22e7sh4n6d5yOn48Suvh17Yg+k6+O69lKF9ZXHe9z6fv5ONjKPpOZdF3kg/7TeZ9AAAAAAAAAAAAAFCWmDIRAAAAAAAAAAAAZY2EGAAAAAAAAAAAAMoaCTEAAAAAAAAAAACUNRJiAAAAAAAAAAAAKGskxAAAAAAAAAAAAFDWSIgBAAAAAAAAAACgrJEQAwAAAAAAAAAAQFkjIQYAAAAAAAAAAICy9v8ZBhOGdE8a2wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -238.86988884377402\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgIZHSYYAIRGMBFCHV\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderIZHSYYAIRGMBFCHV\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animIZHSYYAIRGMBFCHV.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animIZHSYYAIRGMBFCHV.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectIZHSYYAIRGMBFCHV\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgIZHSYYAIRGMBFCHV\";\n",
       "    var slider_id = \"_anim_sliderIZHSYYAIRGMBFCHV\";\n",
       "    var loop_select_id = \"_anim_loop_selectIZHSYYAIRGMBFCHV\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animIZHSYYAIRGMBFCHV = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Imports specifically so we can render outputs in Colab.\n",
    "from matplotlib import animation\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(\n",
    "        plt.gcf(), animate, frames = len(frames), interval=50\n",
    "    )\n",
    "    display(display_animation(anim, default_mode='loop'))\n",
    "    \n",
    "        \n",
    "# display \n",
    "display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
